package main

import (
	"bufio"
	"fmt"
	"os"
)

func max(i, j int) int {
	if i > j {
		return i
	}
	return j
}
func min(i, j int) int {
	if i > j {
		return j
	}
	return i
}

type ListNode struct {
	Val  int
	Next *ListNode
}
type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

var in = bufio.NewReader(os.Stdin)
var out = bufio.NewWriter(os.Stdin)

func main() {
	fmt.Println(minimumTime([]int{9, 3, 10, 5}, 2))
}

// func minimumTime(a []int, totalTrips int) int64 {
// 	ans := 0
// 	ans = sort.Search(1e15, func(t int) bool {
// 		s := 0
// 		for _, v := range a {
// 			s += t / v
// 			if s >= totalTrips {
// 				return true
// 			}
// 		}
// 		return false
// 	})
// 	return int64(ans)
// }

// func minimumTime(time []int, totalTrips int) int64 {
// 	cnt := 0
// 	temp := 0
// 	for temp < totalTrips {
// 		for i := 0; i < len(time); i++ {
// 			if cnt < time[i] {
// 				break
// 			} else {
// 				temp += cnt / time[i]
// 			}
// 			if temp >= totalTrips {
// 				return int64(temp)
// 			}
// 		}
// 		cnt++
// 	}
// 	return 0
// }

// func minimumTime(time []int, totalTrips int) int64 {
// 	sort.Ints(time)
// 	res := make([]int, len(time))
// 	for i := 0; i < len(time); i++ {
// 		cnt := 1
// 		for j := 0; j < i; j++ {
// 			cnt += time[i] / time[j]
// 		}
// 		res[i] = cnt
// 		if cnt >= totalTrips {
// 			return int64(time[i])
// 		}
// 	}
// 	fmt.Println(res)
// 	result := (totalTrips / res[len(res)-1]) * time[len(time)-1]
// 	totalTrips = totalTrips % res[len(res)-1]
// 	if totalTrips == 0 {
// 		return int64(result)
// 	}
// 	for i := 0; i < len(res); i++ {
// 		if res[i] >= totalTrips {
// 			result += time[i]
// 			break
// 		}
// 	}
// 	return int64(result)
// }

// func minimumTime(time []int, totalTrips int) int64 {
// 	sort.Ints(time)
// 	nums := make([]int, len(time))
// 	nums[0] = time[0]
// 	for i := 1; i < len(time); i++ {
// 		nums[i] = nums[i-1] + time[i]
// 	}
// 	res := 0
// 	for totalTrips > nums[len(nums)-1] {
// 		res += totalTrips / nums[len(nums)-1]
// 		totalTrips = totalTrips % nums[len(nums)-1]
// 	}
// 	for i := 0; i < len(nums); i++ {
// 		if nums[i] > totalTrips {
// 			return int64(res + time[i])
// 		}
// 	}
// 	return int64(res)
// }

// func minimumTime(time []int, totalTrips int) int64 {
// 	nums := time
// 	n := totalTrips
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	f := make([]int, n+1)

// 	for i := 1; i <= n; i++ {
// 		f[i] = math.MaxInt32
// 		for j := 0; j < len(nums); j++ {
// 			if i-nums[j] >= 0 {
// 			f[i] = min(f[i], f[i-nums[j]]+nums[j])
// 			}
// 		}
// 	}
// 	if f[n] == math.MaxInt32 {
// 		return -1
// 	}
// 	return int64(f[n])
// }
// func f(n int, nums []int) int {

// }

// func minSteps(s string, t string) int {
// 	res := 0
// 	sset := make(map[byte]int)
// 	tset := make(map[byte]int)
// 	for _, ch := range s {
// 		sset[byte(ch)]++
// 	}
// 	for _, ch := range t {
// 		tset[byte(ch)]++
// 	}
// 	for i, v := range sset {
// 		if val, ok := tset[i]; ok {
// 			res += sum(v, val)
// 		} else {
// 			res += v
// 		}
// 		sset[i] = 0
// 		tset[i] = 0
// 	}
// 	for _, v := range tset {
// 		res += v
// 	}
// 	return res
// }
// func sum(i, j int) int {
// 	if i < j {
// 		return j - i
// 	}
// 	return i - j
// }

// func prefixCount(words []string, pref string) int {
// 	res := 0
// 	for _, word := range words{
// 		if len(word) >= len(pref){
// 			if word[:len(pref)] == pref{
// 				res++
// 			}
// 		}
// 	}
// 	return res
// }
// func deleteNode(root *TreeNode, key int) *TreeNode {
// 	if root != nil && root.Val == key {
// 		if root.Right == nil {
// 			return root.Left
// 		}
// 		root1 := reverse(root.Right) //将目标节点的整个左子树接到右子树的最左节点上，然后返回右子树的头节点
// 		root1.Left = root.Left
// 		return root.Right
// 	}
// 	if root == nil {
// 		return root
// 	}

// 	if root.Val < key {
// 		right := deleteNode(root.Right, key)
// 		root.Right = right
// 	} else {
// 		left := deleteNode(root.Left, key)
// 		root.Left = left
// 	}
// 	return root

// }

// func reverse(root *TreeNode) *TreeNode { //找到最左边的节点
// 	if root == nil {
// 		return root
// 	}
// 	left := reverse(root.Left)
// 	if left == nil {
// 		return root
// 	}
// 	return left
// }

// func addStrings(num1 string, num2 string) string {
// 	n, m := len(num1)-1, len(num2)-1
// 	res := make([]byte, max(n, m)+2)
// 	cnt := len(res) - 1
// 	carry := 0

// 	for n >= 0 || m >= 0 || carry != 0 {
// 		x, y := 0, 0
// 		if n >= 0 {
// 			x = getInt(num1[n])
// 		}
// 		if m >= 0 {
// 			y = getInt(num2[m])
// 		}
// 		sum := carry + x + y
// 		res[cnt] = getTransfer(sum % 36) // 重点在这一步
// 		carry = sum / 36                 // 32 //和这一步
// 		cnt--
// 		n--
// 		m--
// 	}
// 	if res[0] == 0 {
// 		return string(res[1:])
// 	}
// 	return string(res)
// }

// func getTransfer(num int) byte {
// 	if num < 10 {
// 		return byte(num + '0')
// 	}
// 	return byte(num - 10 + 'a')
// }

// func getInt(num byte) int {
// 	if num <= '9' {
// 		return int(num - '0')
// 	}
// 	return int(num + 10 - 'a')
// }

// type LFUCache struct {
// 	capacity    int
// 	sizeToDLink map[int]*DListNode
// 	keyToNode   map[int]*Node
// 	minfreq     int
// }

// func Constructor(capacity int) LFUCache {
// 	l := LFUCache{
// 		capacity:    capacity,
// 		sizeToDLink: make(map[int]*DListNode),
// 		keyToNode:   make(map[int]*Node, 0),
// 	}
// 	return l
// }

// func (this *LFUCache) Get(key int) int {
// 	if _, ok := this.keyToNode[key]; !ok {
// 		return -1
// 	}
// 	node := this.keyToNode[key]
// 	beforefreq := node.freq
// 	node.freq++
// 	this.sizeToDLink[beforefreq].RemoveNode(node)
// 	if this.sizeToDLink[beforefreq].Empty() && beforefreq == this.minfreq {
// 		this.minfreq++
// 	}
// 	if _, ok := this.sizeToDLink[node.freq]; !ok {
// 		this.sizeToDLink[node.freq] = NewDListNode()
// 	}
// 	this.sizeToDLink[node.freq].AddNode(node)
// 	dlink := this.sizeToDLink[this.minfreq]
// 	if dlink.Empty() {
// 		this.minfreq++
// 	}
// 	return node.value
// }

// func (this *LFUCache) Put(key int, value int) {
// 	if this.capacity <= 0 {
// 		return
// 	}
// 	if _, ok := this.keyToNode[key]; ok {
// 		node := this.keyToNode[key]
// 		beforefreq := node.freq
// 		dlink := this.sizeToDLink[beforefreq]
// 		dlink.RemoveNode(node)
// 		node.freq++
// 		this.increaseFrq(node)
// 		node.value = value
// 	} else {
// 		node := NewNode(key, value)

// 		this.keyToNode[key] = node
// 		this.increaseFrq(node)
// 		if len(this.keyToNode) > this.capacity {
// 			this.deleteMinfrq()
// 		}
// 		this.minfreq = 1
// 	}
// 	dlink := this.sizeToDLink[this.minfreq]
// 	if dlink.Empty() {
// 		this.minfreq++
// 	}
// }

// func (this *LFUCache) increaseFrq(node *Node) {
// 	if _, ok := this.sizeToDLink[node.freq]; !ok {
// 		this.sizeToDLink[node.freq] = NewDListNode()
// 	}
// 	dlink := this.sizeToDLink[node.freq]
// 	dlink.AddNode(node)
// }

// func (this *LFUCache) deleteMinfrq() {
// 	dlink := this.sizeToDLink[this.minfreq]
// 	last := dlink.Last()
// 	dlink.RemoveNode(last)
// 	delete(this.keyToNode, last.key)
// }

// type Node struct {
// 	key, value, freq int
// 	next, pre        *Node
// }

// func NewNode(key, value int) *Node {
// 	n := &Node{
// 		key:   key,
// 		value: value,
// 		freq:  1,
// 	}
// 	return n
// }

// type DListNode struct {
// 	head, tail *Node
// }

// func NewDListNode() *DListNode {
// 	d := &DListNode{
// 		head: NewNode(0, 0),
// 		tail: NewNode(0, 0),
// 	}
// 	d.head.next = d.tail
// 	d.tail.pre = d.head
// 	return d
// }

// func (this *DListNode) AddNode(node *Node) {
// 	node.next = this.head.next
// 	node.pre = this.head
// 	this.head.next.pre = node
// 	this.head.next = node
// }

// func (this *DListNode) RemoveNode(node *Node) {
// 	node.next.pre = node.pre
// 	node.pre.next = node.next

// }

// func (this *DListNode) Last() *Node {
// 	return this.tail.pre
// }

// func (this *DListNode) Empty() bool {
// 	return this.head.next == this.tail
// }

// var w sync.WaitGroup

// var kv sync.Map

// func main() {
// 	set("1", 2, 2*time.Second)
// 	set("2", 3, 2*time.Second)
// 	fmt.Println(kv.Load("1"))
// 	fmt.Println(kv.Load("2"))
// 	time.Sleep(3 * time.Second)
// 	fmt.Println(kv.Load("1"))
// 	fmt.Println(kv.Load("2"))
// }
// func set(key string, value interface{}, duration time.Duration) error {
// 	kv.Store(key, value)
// 	time.AfterFunc(duration, func() {
// 		kv.Delete(key)
// 	})
// 	return nil
// }

// func f() {
// 	str := "123456"
// 	for _, v := range str {
// 		go func() {
// 			fmt.Println(string(v))
// 			w.Done()
// 		}()
// 	}
// }
// func one(nums *[]int) {
// 	(*nums) = (*nums)[1:]
// 	fmt.Println(*nums)
// }

// func solve(head *ListNode) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	one, two := &ListNode{}, &ListNode{}
// 	cut1, cut2 := one, two
// 	for head != nil {
// 		cut1.Next, cut2.Next = head, head.Next
// 		cut1, cut2 = cut1.Next, cut2.Next
// 		if head.Next != nil {
// 			head = head.Next.Next
// 		} else {
// 			break
// 		}
// 	}
// 	cut1.Next, cut2.Next = nil, nil
// 	one, two = one.Next, two.Next
// 	ntwo := reverse(two)
// 	res := &ListNode{}
// 	cut := res
// 	for one != nil && ntwo != nil {
// 		if one.Val < ntwo.Val {
// 			cut.Next = one
// 			one = one.Next
// 		} else {
// 			cut.Next = two
// 			two = two.Next
// 		}
// 		cut = cut.Next
// 	}
// 	if one != nil {
// 		cut.Next = one
// 	}
// 	if two != nil {
// 		cut.Next = two
// 	}
// 	return res.Next
// }
// func reverse(head *ListNode) *ListNode {
// 	var pre *ListNode
// 	for head != nil {
// 		temp := head.Next
// 		head.Next = pre
// 		pre = head
// 		head = temp
// 	}
// 	return pre
// }

// func NewTree(n int) *TreeNode {
// 	nums := make([]int, 0, 3)
// 	for i := 0; i < 3; i++ {
// 		nums = append(nums, i)
// 	}
// 	root := &TreeNode{
// 		Val: nums[0],
// 	}
// 	if nums[1] == 0 {
// 		root.Left = nil
// 	} else {
// 		root.Left = NewTree(n)
// 	}
// 	if nums[2] == 0 {
// 		root.Right = nil
// 	} else {
// 		root.Right = NewTree(n)
// 	}
// 	return root
// }

// func readInt() int {
// 	b := true
// 	res := 0
// 	for i, _ := in.ReadByte(); i != ' ' && i != '\n'; i, _ = in.ReadByte() {
// 		if i == '-' {
// 			b = false
// 			continue
// 		}
// 		res = res*10 + int(i-'0')
// 	}
// 	if !b {
// 		return -1 * res
// 	}
// 	return res
// }

// func readString() string {
// 	s, _ := in.ReadString('\n')
// 	return s[:len(s)-1]
// }

// func readString() string {
// 	str, _ := in.ReadString('\n')
// 	return str[:len(str)-1]
// }

// func readInt() int {
// 	b := true
// 	res := 0
// 	for i, _ := in.ReadByte(); i != ' ' && i != '\n'; i, _ = in.ReadByte() {
// 		if i == '-' {
// 			b = false
// 			continue
// 		}
// 		res = res*10 + int(i-'0')
// 	}
// 	if !b {
// 		return -1 * res
// 	}
// 	return res
// }

// func coutPairs(nums []int, k int) int64 {
// 	res := 0
// 	cnt := 0 //表示不可以被整除的数字
// 	index := make(map[int]int)
// 	sums := make([]int, len(nums))
// 	sums[0] = nums[0]
// 	for i := 0; i < len(nums); i++{
// 		sums[i]  = sum[i - 1] * nums[i]
// 	}
// 	sort.Ints(nums)
// 	for i := 0; i < len(nums); i++ {
// 		if nums[i]%k != 0 {
// 			index[nums[i]]++
// 			cnt++
// 		} else {
// 			res += len(nums) - i - 1
// 			res += cnt
// 		}
// 	}
// 	return int64(res)
// }
// [8,10,2,5,9,6,3,8,2]
// 6

// func coutPairs(nums []int, k int) int64 {
// 	res := 0
// 	cnt := 0 //表示不可以被整除的数字
// 	index := make(map[int]bool)
// 	for i := 0; i < len(nums); i++ {
// 		if nums[i]%k != 0 {
// 			for h := range index {
// 				if (h*nums[i])%k == 0 {
// 					res++
// 				}
// 				index[nums[i]] = true
// 			}
// 		} else {
// 			res += len(nums) - i - 1
// 			res += cnt
// 		}
// 	}
// 	return int64(res)
// }

// func repeatLimitedString(s string, repeatLimit int) string {
// 	nums := make([]int, 26)
// 	for _, ch := range s {
// 		nums[ch-'a']++
// 	}
// 	res := make([]byte, 0)
// 	for i := len(nums) - 1; i >= 0; i-- {
// 		if nums[i] != 0 {
// 			if nums[i] <= repeatLimit {
// 				res = append(res, bytes.Repeat([]byte{byte('a' + i)}, nums[i])...)
// 				nums[i] = 0
// 			} else {
// 				for nums[i] != 0 {
// 					res = append(res, bytes.Repeat([]byte{byte('a' + i)}, min(repeatLimit, nums[i]))...)
// 					nums[i] = max(0, nums[i]-repeatLimit)
// 					flag := false
// 					fmt.Println(res)
// 					if nums[i] != 0 {
// 						for j := i - 1; j >= 0; j-- {
// 							if nums[j] != 0 {
// 								nums[j]--
// 								res = append(res, byte('a'+j))
// 								flag = true
// 								break
// 							}
// 						}
// 					}
// 					if !flag {
// 						break
// 					}
// 				}
// 			}
// 		}
// 	}
// 	return string(res)
// }

// //第一题
// func countEven(num int) int {
// 	res := 0
// 	for i := 2; i <= num; i++ {
// 		k := 0
// 		val := i
// 		for val != 0 {
// 			k += (val % 10)
// 			val = val / 10
// 		}
// 		if k%2 == 0 {
// 			res++
// 		}
// 	}
// 	return res
// }

// func mergeNodes(head *ListNode) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	result := &ListNode{}
// 	newhead := result

// 	for head != nil {
// 		sum := 0
// 		for head.Next != nil && head.Next.Val != 0 {
// 			sum += head.Next.Val
// 			head = head.Next
// 		}
// 		node := &ListNode{
// 			Val: sum,
// 		}
// 		newhead.Next = node
// 		newhead = newhead.Next
// 		head = head.Next
// 	}
// 	return result.Next
// }

// //第二题
// func solve(root *ListNode) *ListNode {
// 	if root == nil {
// 		return nil
// 	}
// 	result := &ListNode{}
// 	head := result

// 	for root != nil {
// 		sum := 0
// 		for root.Next != nil && root.Next.Val != 0 {
// 			sum += root.Next.Val
// 			root = root.Next
// 		}
// 		node := &ListNode{
// 			Val: sum,
// 		}
// 		head.Next = node
// 		head = head.Next
// 	}
// 	return result.Next
// }

// func goodTriplets(nums1 []int, nums2 []int) int64 {
// 	m1 := make(map[int]int)
// 	m2 := make(map[int]int)
// 	for i := 0; i < len(nums1); i++ {
// 		m1[nums1[i]] = i
// 	}
// 	for i := 0; i < len(nums2); i++ {
// 		m2[nums2[i]] = i
// 	}

// 	res := 0
// 	// indexs := make(map[int]int, 0)
// 	for i := 0; i < len(nums1); i++ {
// 		x := m2[nums1[i]]
// 		if i > x {
// 			for j := i + 1; j < len(nums1); j++ {
// 				y := m2[nums1[j]]
// 				if x > y {
// 					continue
// 				}
// 				if y > j {
// 					for k := y + 1; k < len(nums2); k++ {
// 						if m1[nums2[k]] < j || m1[nums2[k]] < i {
// 							continue
// 						}
// 						res++
// 					}
// 				} else {
// 					for k := j + 1; k < len(nums2); k++ {
// 						if m2[nums1[k]] < x || m2[nums1[k]] < y {
// 							continue
// 						}
// 						res++
// 					}
// 				}
// 			}
// 		} else {
// 			for j := x + 1; j < len(nums2); j++ {
// 				y := m1[nums2[j]]
// 				if i > y {
// 					continue
// 				}
// 				if y > j {
// 					for k := y + 1; k < len(nums1); k++ {
// 						if m2[nums1[k]] < j || m2[nums1[k]] < x {
// 							continue
// 						}
// 						res++
// 					}
// 				} else {
// 					for k := j + 1; k < len(nums2); k++ {
// 						if m1[nums2[k]] < i || m1[nums2[k]] < y {
// 							continue
// 						}
// 						res++
// 					}
// 				}
// 			}
// 		}
// 	}
// 	return int64(res)
// }

// func maximumEvenSplit(finalSum int64) []int64 {
// 	if finalSum%2 != 0 {
// 		return nil
// 	}
// 	var sum int64
// 	res := []int64{}
// 	var index int64
// 	for index = 2; ; index += 2 {
// 		if sum+index > finalSum {
// 			res[len(res)-1] += finalSum - sum
// 			return res
// 		} else if sum+index == finalSum {
// 			res = append(res, int64(index))
// 			return res
// 		}
// 	}
// 	return res
// }

// func sumOfThree(num int64) []int64 {
// 	if num%3 != 0 {
// 		return nil
// 	}
// 	num1 := num / 3
// 	num0 := num1 - 1
// 	num2 := num1 + 1
// 	return []int64{num0, num1, num2}
// }

// func sumOfThree(num int64) []int64 {
// 	var i int64
// 	for {
// 		if int64(3*i+3) == num {
// 			return []int64{i, i + 1, i + 2}
// 		} else if int64(3*i+3) > num {
// 			return nil
// 		} else {
// 			i++
// 		}
// 	}
// 	return nil
// }

// func countPairs(nums []int, k int) int {
// 	res := 0
// 	for i := 0; i < len(nums); i++ {
// 		for j := i + 1; j < len(nums); j++ {
// 			if nums[i] != nums[j] {
// 				break
// 			}
// 			if (i*j)%k == 0 {
// 				res++
// 			}
// 			j++
// 		}
// 	}
// 	return res
// }

// func getKthElement(nums1, nums2 []int, k int) int {
// 	index1, index2 := 0, 0
// 	for {
// 		if index1 == len(nums1) {
// 			return nums2[index2+k-1]
// 		}
// 		if index2 == len(nums2) {
// 			return nums1[index1+k-1]
// 		}
// 		if k == 1 {
// 			return min(nums1[index1], nums2[index2])
// 		}
// 		half := k / 2
// 		newIndex1 := min(index1+half, len(nums1)) - 1
// 		newIndex2 := min(index2+half, len(nums2)) - 1
// 		pivot1, pivot2 := nums1[newIndex1], nums2[newIndex2]
// 		if pivot1 <= pivot2 {
// 			k -= (newIndex1 - index1 + 1)
// 			index1 = newIndex1 + 1
// 		} else {
// 			k -= (newIndex2 - index2 + 1)
// 			index2 = newIndex2 + 1
// 		}
// 	}
// 	return 0
// }

// func solve(str string) string {
// 	sbyte := []byte(str)
// 	i := 0
// 	for i < len(sbyte)-1 {
// 		if string(sbyte[i:i+2]) == "ab" {
// 			sbyte = append(sbyte[:i], sbyte[i+2:]...)
// 			i--
// 		} else {
// 			i++
// 		}
// 	}
// 	return string(sbyte)
// }

// type SORTracker struct {
// 	small *hp
// 	big   *hp
// }

// func Constructor() SORTracker {
// 	small := &hp{small: true}
// 	big := &hp{small: false}
// 	return SORTracker{small, big}
// }

// func (this *SORTracker) Add(name string, score int) {
// 	p := pair{name, score}
// 	this.small.push(p)
// 	this.big.push(this.small.pop())
// }

// func (this *SORTracker) Get() string {
// 	p := this.big.pop()
// 	this.small.push(p)
// 	return p.name
// }

// type pair struct {
// 	name  string
// 	score int
// }

// type hp struct {
// 	small bool
// 	data  []pair
// }

// func (h hp) Len() int { return len(h.data) }
// func (h hp) Less(i, j int) bool {
// 	if h.small == true {
// 		return h.data[i].score < h.data[j].score || (h.data[i].score == h.data[j].score && h.data[i].name > h.data[j].name)
// 	} else {
// 		return h.data[i].score > h.data[j].score || (h.data[i].score == h.data[j].score && h.data[i].name < h.data[j].name)
// 	}
// }
// func (h hp) Swap(i, j int)         { h.data[i], h.data[j] = h.data[j], h.data[i] }
// func (h *hp) Push(v interface{})   { h.data = append(h.data, v.(pair)) }
// func (h *hp) Pop() (v interface{}) { a := h.data; h.data, v = a[:len(a)-1], a[len(a)-1]; return }
// func (h *hp) push(v pair)          { heap.Push(h, v) }
// func (h *hp) pop() pair            { return heap.Pop(h).(pair) }
// func (h *hp) top() pair            { a := h.data; return a[0] }

// func maximumDetonation(bombs [][]int) int {

// 	bobmg := make([][]int, len(bombs))
// 	for i := 0; i < len(bombs); i++ {
// 		for j := 0; j < len(bombs); j++ {
// 			val := math.Pow(float64(bombs[i][0]-bombs[j][0]), 2) + math.Pow(float64(bombs[i][1]-bombs[j][1]), 2)
// 			if val <= math.Pow(float64(bombs[i][2]), 2) {
// 				bobmg[i] = append(bobmg[i], j)
// 			}
// 		}
// 	}
// 	// indexs := make([]int, len(bombs))
// 	res := 1
// 	var dfs func(bom int, indexs []int)
// 	dfs = func(bom int, indexs []int) {
// 		v := bobmg[bom]
// 		n := len(v)
// 		for i := 0; i < n; i++ {
// 			if indexs[v[i]] == 1 {
// 				continue
// 			}
// 			indexs[v[i]] = 1
// 			dfs(v[i], indexs)
// 		}
// 	}
// 	for i := 0; i < len(bombs); i++ {
// 		indexs := make([]int, len(bombs))
// 		indexs[i] = 1
// 		dfs(i, indexs)
// 		res = max(res, Sumone(indexs))
// 	}
// 	return res
// }
// func Sumone(num []int) int {
// 	res := 0
// 	for i := 0; i < len(num); i++ {
// 		if num[i] == 1 {
// 			res++
// 		}
// 	}
// 	return res
// }

// func maxSubsequence(nums []int, k int) []int {

// 	r := len(nums) - 1
// 	sums := make([][]int, 0)
// 	indexs := make(map[int]int)
// 	for i := 0; i < len(nums); i++ {
// 		indexs[nums[i]] = i
// 	}
// 	sort.Ints(nums)

// 	for k > 0 {
// 		sums = append(sums, []int{nums[r], indexs[nums[r]]})
// 		r--
// 		k--
// 	}

// 	sort.Slice(sums, func(i, j int) bool {
// 		return sums[i][1] < sums[j][1]
// 	})

// 	result := make([]int, len(sums))
// 	for i := 0; i < len(sums); i++ {
// 		result[i] = sums[i][0]
// 	}
// 	return result

// }

// func transInfor(str string) string {
// 	sbyte := []byte(str)
// 	for i := 0; i < len(sbyte); i++ {
// 		if sbyte[i] == '[' {
// 			sbyte[i] = '{'
// 		} else if sbyte[i] == ']' {
// 			sbyte[i] = '}'
// 		}
// 	}
// 	return string(sbyte)
// }

// var out = bufio.NewWriter(os.Stdout)

// // 桶排序
// func main() {
// 	fmt.Println()
// 	for i := 2 * 5; i < 5; i++ {

// 	}
// }
// int partition(int L[],int l,int r){
//     int i,num=l;
//     for(i=l+1;i<=r;i++){
//         if(L[i]<L[l]){
//             swap(L[i],L[++num]);
//         }
//     }
//     swap(L[l],L[num]);
//     return num;
// }
// void getmid(int L[],int l,int r){
//     int mid=(l+r)/2;
//     while(1){
//         int pos=partition(L,l,r);
//         if(pos==mid) break;
//         else if(pos>mid) r=pos-1;
//         else l=pos+1;
//     }
//     printf("%d\n",L[mid]);
// }
// //得到第k大
// int getMinK(int v[], int l, int r, int k){
//     if(l<r){
//         int i=l,j=l;
//         for(;j<r;j++){
//             if(v[j]<v[r]){
//                 swap(v[i++],v[j]);
//             }
//         }
//         swap(v[i],v[r]);
//         if(k==i)  return v[i];
//         else if(k<i)  return getMinK(v,l,i-1,k);
//         else return getMinK(v,i+1,r,k);
//     }
//     else return v[l];
// }

// int main(){
//     int a[]={1,5,3,4,2,4};
//     getmid(a,0,4);
//     //int ans=getMinK(a,0,4,2);
//     //printf("%d\n",ans);
//     return 0;
// }

// type solve struct{}

// var slexample *solve
// var mutex sync.Mutex

// func NewSolve() *solve {
// 	if slexample == nil {
// 		mutex.Lock()
// 		defer mutex.Unlock()
// 		if slexample == nil {
// 			slexample = &solve{}
// 			return slexample
// 		}
// 	}
// 	return slexample
// }

// func slove(nums []int) []int {
// 	res := make([]int, len(nums))
// 	stack := make([]int, 0)
// 	// l := 0
// 	for l := 0; l < len(nums); l++ {
// 		for len(stack) > 0 && nums[stack[len(stack)-1]] < nums[l] {
// 			res[stack[len(stack)-1]] = nums[l]
// 			stack = stack[:len(stack)-1]
// 		}
// 		stack = append(stack, l)
// 	}
// 	for len(stack) != 0 {
// 		res[stack[0]] = -1
// 		stack = stack[1:]
// 	}
// 	return res
// }

// 采用回溯取出每两个数字遍历每一种操作符
// func FirstPositive(nums []int) int {
// 	l, r := 0, len(nums)-1
// 	for l <= r {
// 		mid := (l + r) / 2
// 		if nums[mid] <= 0 {
// 			l = mid + 1
// 		} else {
// 			r = mid - 1
// 		}
// 	}
// 	if l == len(nums) {
// 		return -1
// 	} else {
// 		return nums[l]
// 	}
// }

// func minimumOperations(nums []int) int {
// 	if len(nums) == 0 || len(nums) == 1 {
// 		return 0
// 	}
// 	if len(nums) == 2 {
// 		if nums[0] != nums[1] {
// 			return 0
// 		} else {
// 			return 1
// 		}
// 	}

// 	nums1 := make([]int, 0)
// 	nums2 := make([]int, 0)
// 	for i := 0; i < len(nums); i += 2 {
// 		nums1 = append(nums1, nums[i])
// 	}
// 	for i := 1; i < len(nums); i += 2 {
// 		nums2 = append(nums2, nums[i])
// 	}
// 	//统计每个nums1里出现的次数
// 	nums1map := make(map[int]int)
// 	nums2map := make(map[int]int)
// 	for _, v := range nums1 {
// 		nums1map[v]++
// 	}
// 	for _, v := range nums2 {
// 		nums2map[v]++
// 	}
// 	nums1sort := make([][]int, 0)
// 	nums2sort := make([][]int, 0)
// 	for i, v := range nums1map {
// 		nums1sort = append(nums1sort, []int{i, v})
// 	}
// 	for i, v := range nums2map {
// 		nums2sort = append(nums2sort, []int{i, v})
// 	}
// 	sort.Slice(nums1sort, func(i, j int) bool { return nums1sort[i][1] > nums1sort[j][1] })
// 	sort.Slice(nums2sort, func(i, j int) bool { return nums2sort[i][1] > nums2sort[j][1] })

// 	i, j := 0, 0
// 	if nums1sort[i][0] != nums2sort[j][0] {
// 		return len(nums1) - nums1sort[i][1] + len(nums2) - nums2sort[j][1]
// 	}
// 	if len(nums1)-nums1sort[i][1] == 0 && len(nums2)-nums2sort[j][1] == 0 {
// 		return min(len(nums1), len(nums2))
// 	}
// 	if len(nums1)-nums1sort[i][1] > len(nums2)-nums2sort[j][1] {
// 		return len(nums1) - nums1sort[i+1][1] + len(nums2) - nums2sort[j][1]
// 	} else {
// 		return len(nums1) - nums1sort[i][1] + len(nums2) - nums2sort[j+1][1]
// 	}
// }

// func minimumRemoval(beans []int) int64 {
// 	if len(beans) == 0 {
// 		return 0
// 	}
// 	sort.Ints(beans)
// 	res := math.MaxInt64
// 	// indexs := make([]int, len(beans))
// 	sum := int64(beans[0])
// 	for i := 1; i < len(beans); i++ {
// 		// indexs[i] = indexs[i-1] + beans[i]
// 		sum += int64(beans[i])
// 	}
// 	for i := 0; i < len(beans); i++ {
// 		temp := sum - int64(len(beans)-i)*int64(beans[i])
// 		res = min(res, temp)
// 	}
// 	return int64(res)
// }

// func minimumRemoval(beans []int) int64 {
// 	if len(beans) == 0 {
// 		return 0
// 	}
// 	f := make([][]int, len(beans)) // 1:次数，2:最小值，3:包含的0的个数
// 	for i := 0; i < len(f); i++ {
// 		f[i] = make([]int, 3)
// 	}
// 	f[0] = []int{0, beans[0], 0}
// 	if beans[0] == 0 {
// 		f[0][2] = 1
// 	}
// 	for i := 1; i < len(beans); i++ {
// 		f[i] = f[i-1]
// 		if beans[i] == 0 {
// 			f[i][2]++
// 			continue
// 		}
// 		if beans[i] == f[i][1] {
// 			continue
// 		}
// 		if f[i][1] == 0 {
// 			f[i][1] = beans[i]
// 			continue
// 		}
// 		v1, v2 := math.MaxInt32, math.MaxInt32
// 		if beans[i] > f[i][1] {
// 			v1 = beans[i] - f[i][1]
// 		} else {
// 			v2 = (f[i][1] - beans[i]) * (i - f[i][2])
// 		}
// 		if v1 < v2 {
// 			f[i][0] += v1
// 		} else {
// 			f[i][0] += v2
// 			f[i][1] = beans[i]
// 		}

// 	}
// 	return int64(f[len(beans)-1][0])
// }

// func minimumOperations(nums []int) int {
// 	if len(nums) == 0 || len(nums) == 1 {
// 		return 0
// 	}
// 	if len(nums) == 2 {
// 		if nums[0] != nums[1] {
// 			return 0
// 		} else {
// 			return 1
// 		}
// 	}

// 	nums1 := make([]int, 0)
// 	nums2 := make([]int, 0)
// 	for i := 0; i < len(nums); i += 2 {
// 		nums1 = append(nums1, nums[i])
// 	}
// 	for i := 1; i < len(nums); i += 2 {
// 		nums2 = append(nums2, nums[i])
// 	}
// 	//统计每个nums1里出现的次数
// 	nums1map := make(map[int]int)
// 	nums2map := make(map[int]int)
// 	for _, v := range nums1 {
// 		nums1map[v]++
// 	}
// 	for _, v := range nums2 {
// 		nums2map[v]++
// 	}
// 	nums1sort := make([][]int, 0)
// 	nums2sort := make([][]int, 0)
// 	for i, v := range nums1map {
// 		nums1sort = append(nums1sort, []int{i, v})
// 	}
// 	for i, v := range nums2map {
// 		nums2sort = append(nums2sort, []int{i, v})
// 	}
// 	sort.Slice(nums1sort, func(i, j int) bool { return nums1sort[i][1] > nums1sort[j][1] })
// 	sort.Slice(nums2sort, func(i, j int) bool { return nums1sort[i][1] > nums1sort[j][1] })

// 	i, j := 0, 0
// 	if nums1sort[i][0] != nums2sort[j][0] {
// 		return len(nums1) - nums1sort[i][1] + len(nums2) - nums2sort[j][1]
// 	}
// 	if len(nums1)-nums1sort[i][1] == 0 && len(nums2)-nums2sort[j][1] == 0 {
// 		return min(len(nums1), len(nums2))
// 	}
// 	if len(nums1)-nums1sort[i][1] > len(nums2)-nums2sort[j][1] {
// 		return len(nums1) - nums1sort[i+1][1] + len(nums2) - nums2sort[j][1]
// 	} else {
// 		return len(nums1) - nums1sort[i][1] + len(nums2) - nums2sort[j+1][1]
// 	}
// }

// func countOperations(num1 int, num2 int) int {
// 	if num1 == 0 || num2 == 0{
// 		return 0
// 	}
// 	res := 0
// 	for num1 != 0 && num2 != 0{
// 		if num1 > num2{
// 			num1 = num1 - num2
// 		}else{
// 			num2 = num2 - num1
// 		}
// 		res++
// 	}
// 	return res
// }

// type LFUCache struct {
// 	capacity    int
// 	sizeToDLink map[int]*DListNode
// 	keyToNode   map[int]*Node
// 	minfreq     int
// 	cnt         int
// }

// func Constructor(capacity int) LFUCache {
// 	l := LFUCache{
// 		capacity:    capacity,
// 		sizeToDLink: make(map[int]*DListNode),
// 		keyToNode:   make(map[int]*Node, 0),
// 	}
// 	return l
// }

// func (this *LFUCache) Get(key int) int {
// 	node := this.keyToNode[key]
// 	beforefreq := node.freq
// 	node.freq++
// 	this.sizeToDLink[beforefreq].RemoveNode(node)
// 	if this.sizeToDLink[beforefreq].cnt == 0 && beforefreq == this.minfreq {
// 		this.minfreq++
// 	}
// 	if _, ok := this.sizeToDLink[node.freq]; !ok {
// 		this.sizeToDLink[node.freq] = NewDListNode()
// 	}
// 	this.sizeToDLink[node.freq].AddNode(node)
// 	return node.value
// }

// func (this *LFUCache) Put(key int, value int) {
// 	if this.capacity <= 0 {
// 		return
// 	}
// 	if _, ok := this.keyToNode[key]; ok {
// 		node := this.keyToNode[key]
// 		beforefreq := node.freq
// 		dlink := this.sizeToDLink[beforefreq]
// 		dlink.RemoveNode(node)
// 		node.freq++
// 		this.increaseFrq(node)
// 		node.value = value
// 	} else {
// 		node := NewNode(key, value)
// 		this.minfreq = 1
// 		this.keyToNode[key] = node
// 		this.increaseFrq(node)
// 		if len(this.keyToNode) >= this.capacity {
// 			this.deleteMinfrq()
// 		}
// 	}
// 	dlink := this.sizeToDLink[this.minfreq]
// 	if dlink.Empty() {
// 		this.minfreq++
// 	}
// }

// func (this *LFUCache) increaseFrq(node *Node) {
// 	if _, ok := this.sizeToDLink[node.freq]; !ok {
// 		this.sizeToDLink[node.freq] = NewDListNode()
// 	}
// 	dlink := this.sizeToDLink[node.freq]
// 	dlink.AddNode(node)
// }

// func (this *LFUCache) deleteMinfrq() {
// 	dlink := this.sizeToDLink[this.minfreq]
// 	last := dlink.Last()
// 	dlink.RemoveNode(last)
// 	delete(this.keyToNode, last.key)
// }

// type Node struct {
// 	key, value, freq int
// 	next, pre        *Node
// }

// func NewNode(key, value int) *Node {
// 	n := &Node{
// 		key:   key,
// 		value: value,
// 		freq:  1,
// 	}
// 	return n
// }

// type DListNode struct {
// 	head, tail *Node
// }

// func NewDListNode() *DListNode {
// 	d := &DListNode{
// 		head: NewNode(0, 0),
// 		tail: NewNode(0, 0),
// 	}
// 	d.head.next = d.tail
// 	d.tail.pre = d.head
// 	return d
// }

// func (this *DListNode) AddNode(node *Node) {
// 	node.next = this.head.next
// 	node.pre = this.head
// 	this.head.next.pre = node
// 	this.head.next = node
// }

// func (this *DListNode) RemoveNode(node *Node) {
// 	node.next.pre = node.pre
// 	node.pre.next = node.next

// }

// func (this *DListNode) Last() *Node {
// 	return this.tail.pre
// }

// func (this *DListNode) Empty() bool {
// 	return this.head.next == this.tail
// }

// type LFUCache struct {
// 	capacity    int
// 	sizeToDLink map[int]*DListNode
// 	keyToNode   map[int]*Node
// 	minfreq     int
// 	cnt         int
// }

// func Constructor(capacity int) LFUCache {
// 	l := LFUCache{
// 		capacity:    capacity,
// 		sizeToDLink: make(map[int]*DListNode),
// 		keyToNode:   make(map[int]*Node, 0),
// 	}
// 	return l
// }

// func (this *LFUCache) Get(key int) int {
// 	node := this.keyToNode[key]
// 	beforefreq := node.freq
// 	node.freq++
// 	this.sizeToDLink[beforefreq].RemoveNode(node)
// 	if this.sizeToDLink[beforefreq].cnt == 0 && beforefreq == this.minfreq {
// 		this.minfreq++
// 	}
// 	if _, ok := this.sizeToDLink[node.freq]; !ok {
// 		this.sizeToDLink[node.freq] = NewDListNode()
// 	}
// 	this.sizeToDLink[node.freq].AddNode(node)
// 	return node.value
// }

// func (this *LFUCache) Put(key int, value int) {
// 	if _, ok := this.keyToNode[key]; ok {
// 		node := this.keyToNode[key]
// 		beforefreq := node.freq
// 		node.freq++
// 		this.sizeToDLink[beforefreq].RemoveNode(node)
// 		if this.sizeToDLink[beforefreq].cnt == 0 && beforefreq == this.minfreq {
// 			this.minfreq++
// 		}
// 		if _, ok := this.sizeToDLink[node.freq]; !ok {
// 			this.sizeToDLink[node.freq] = NewDListNode()
// 		}
// 		this.sizeToDLink[node.freq].AddNode(node)
// 		node.value = value
// 	} else {
// 		node := NewNode(key, value)
// 		this.keyToNode[key] = node
// 		this.minfreq = node.freq
// 		this.cnt++
// 		if _, ok := this.sizeToDLink[node.freq]; !ok {
// 			this.sizeToDLink[node.freq] = NewDListNode()
// 		}
// 		this.sizeToDLink[node.freq].AddNode(node)
// 		if this.cnt > this.capacity {
// 			this.sizeToDLink[this.minfreq].RemoveTail()
// 			if this.sizeToDLink[this.minfreq].cnt == 0 {
// 				this.minfreq++
// 			}
// 		}
// 	}
// }

// type Node struct {
// 	key, value, freq int
// 	next, pre        *Node
// }

// func NewNode(key, value int) *Node {
// 	n := &Node{
// 		key:   key,
// 		value: value,
// 		freq:  0,
// 	}
// 	return n
// }

// type DListNode struct {
// 	head, tail *Node
// 	cnt        int
// }

// func NewDListNode() *DListNode {
// 	d := &DListNode{
// 		head: NewNode(0, 0),
// 		tail: NewNode(0, 0),
// 	}
// 	d.head.next = d.tail
// 	d.tail.pre = d.head
// 	return d
// }

// func (this *DListNode) AddNode(node *Node) {
// 	node.next = this.head.next
// 	node.pre = this.head
// 	this.head.next.pre = node
// 	this.head.next = node
// 	this.cnt++
// }

// func (this *DListNode) RemoveNode(node *Node) {
// 	node.next.pre = node.pre
// 	node.pre.next = node.next
// 	this.cnt--
// }

// func (this *DListNode) RemoveTail() {
// 	this.tail.pre = this.tail.pre.pre
// 	this.tail.pre.next = this.tail
// 	this.cnt--
// }

// type LRUCache struct {
// 	capacity   int
// 	size       int
// 	head, tail *DLinkNode
// 	cache      map[int]*DLinkNode
// }

// type DLinkNode struct {
// 	key   int
// 	value int
// 	next  *DLinkNode
// 	pre   *DLinkNode
// }

// func Constructor(capacity int) LRUCache {
// 	l := LRUCache{
// 		capacity: capacity,
// 		size:     0,
// 		cache:    make(map[int]*DLinkNode),
// 	}

// 	l.head, l.tail = newDLickNode(0, 0), newDLickNode(0, 0)
// 	l.head.next = l.tail
// 	l.tail.pre = l.head
// 	return l
// }

// func newDLickNode(key, value int) *DLinkNode {
// 	d := &DLinkNode{
// 		key:   key,
// 		value: value,
// 	}
// 	return d
// }
// func (this *LRUCache) Get(key int) int {
// 	if _, ok := this.cache[key]; !ok {
// 		return -1
// 	}
// 	this.MoveHead(key)
// 	return this.cache[key].value
// }

// func (this *LRUCache) Put(key int, value int) {
// 	if _, ok := this.cache[key]; !ok {
// 		node := newDLickNode(key, value)
// 		this.cache[key] = node
// 		this.AddHeader(node)
// 		this.size++
// 		if this.size > this.capacity {
// 			this.RemoveTail()
// 		}
// 	} else {
// 		this.cache[key].value = value
// 		this.MoveHead(key)
// 	}
// }

// func (this *LRUCache) AddHeader(node *DLinkNode) {
// 	node.pre = this.head
// 	node.next = this.head.next
// 	this.head.next.pre = node
// 	this.head.next = node
// }

// func (this *LRUCache) RemoveNode(key int) {
// 	this.cache[key].pre.next = this.cache[key].next
// 	this.cache[key].next.pre = this.cache[key].pre
// }

// func (this *LRUCache) MoveHead(key int) {
// 	this.RemoveNode(key)
// 	this.cache[key].next = this.head.next
// 	this.cache[key].pre = this.head
// 	this.head.next.pre = this.cache[key]
// 	this.head.next = this.cache[key]
// }

// func (this *LRUCache) RemoveTail() {
// 	this.tail.pre = this.tail.pre.pre
// 	this.tail.pre.next = this.tail
// 	this.size--

// }

// func bucketSort(nums []int, size int) {
// 	minvalue, maxvalue := nums[0], nums[0]
// 	for i := 1; i < len(nums); i++ {
// 		if nums[i] < minvalue {
// 			minvalue = nums[i]
// 		}
// 		if nums[i] > maxvalue {
// 			maxvalue = nums[i]
// 		}
// 	}
// 	buckets := make([][]int, (maxvalue-minvalue)/size+1)
// 	for i := 0; i < len(nums); i++ {
// 		buckets[(nums[i]-minvalue)/size] = append(buckets[(nums[i]-minvalue)/size], nums[i])
// 	}
// 	index := 0
// 	for _, bucket := range buckets {
// 		sort.Ints(bucket)
// 		for _, v := range bucket {
// 			nums[index] = v
// 			index++
// 		}
// 	}
// }

// func bucketSort(numArr []int, bucketSize int) {

// 	minValue := numArr[0]
// 	maxValue := numArr[0]

// 	for i := 0; i < len(numArr); i++ {
// 		if minValue > numArr[i] {
// 			minValue = numArr[i]
// 		}
// 		if maxValue < numArr[i] {
// 			maxValue = numArr[i]
// 		}
// 	}

// 	// 桶切片初始化
// 	bucketCount := make([][]int, (maxValue-minValue)/bucketSize+1)

// 	// 数据入桶
// 	for i := 0; i < len(numArr); i++ {
// 		bucketCount[(numArr[i]-minValue)/bucketSize] = append(bucketCount[(numArr[i]-minValue)/bucketSize], numArr[i])
// 	}

// 	key := 0
// 	fmt.Println(bucketCount)
// 	// 对每个桶进行排序，这里使用冒泡排序
// 	for _, bucket := range bucketCount {
// 		sort.Ints(bucket)
// 		for _, value := range bucket {
// 			numArr[key] = value
// 			key = key + 1
// 		}
// 	}
// 	return
// }

// func HeapSort(nums []int) []int {
// 	for i := len(nums)/2 - 1; i >= 0; i-- {
// 		sink(nums, i, len(nums))
// 	}

// 	for i := len(nums) - 1; i >= 1; i-- {
// 		nums[0], nums[i] = nums[i], nums[0]
// 		sink(nums, 0, i)
// 	}
// 	fmt.Println(nums)
// 	nums = append([]int{0}, nums...)
// 	for i := len(nums)/2 - 1; i >= 0; i-- {
// 		sink(nums, i, len(nums))
// 	}

// 	for i := len(nums) - 1; i >= 1; i-- {
// 		nums[0], nums[i] = nums[i], nums[0]
// 		sink(nums, 0, i)
// 	}
// 	fmt.Println(nums)

// 	return nums
// }

// func sink(nums []int, index int, length int) {
// 	for {
// 		l := 2*index + 1
// 		r := 2*index + 2
// 		i := index
// 		if l < length && nums[l] > nums[i] {
// 			i = l
// 		}
// 		if r < length && nums[r] > nums[i] {
// 			i = r
// 		}
// 		if i == index {
// 			break
// 		}
// 		nums[i], nums[index] = nums[index], nums[i]
// 		index = i
// 	}
// }

// func HeapSort(a []int) []int {
// 	// 1、无序数组a
// 	// 2、将无序数组a构建为一个大根堆
// 	for i := len(a)/2 - 1; i >= 0; i-- {
// 		sink(a, i, len(a))
// 	}
// 	// 3、交换a[0]和a[len(a)-1]
// 	// 4、然后把前面这段数组继续下沉保持堆结构，如此循环即可
// 	for i := len(a) - 1; i >= 1; i-- {
// 		// 从后往前填充值
// 		swap(a, 0, i)
// 		// 前面的长度也减一
// 		sink(a, 0, i)
// 	}
// 	return a
// }

// func sink(a []int, i int, length int) {
// 	for {
// 		// 左节点索引(从0开始，所以左节点为i*2+1)
// 		l := i*2 + 1
// 		// 右节点索引
// 		r := i*2 + 2
// 		// idx保存根、左、右三者之间较大值的索引
// 		idx := i
// 		// 存在左节点，左节点值较大，则取左节点
// 		if l < length && a[l] > a[idx] {
// 			idx = l
// 		}
// 		// 存在右节点，且值较大，取右节点
// 		if r < length && a[r] > a[idx] {
// 			idx = r
// 		}
// 		// 如果根节点较大，则不用下沉
// 		if idx == i {
// 			break
// 		}
// 		// 如果根节点较小，则交换值，并继续下沉
// 		swap(a, i, idx)
// 		// 继续下沉idx节点
// 		i = idx
// 	}
// }
// func swap(a []int, i, j int) {
// 	a[i], a[j] = a[j], a[i]
// }

// func quickSort(nums []int, start, end int) {
// 	if start >= end {
// 		return
// 	}
// 	pivot := nums[end]
// 	l, r := start, start
// 	for r < end {
// 		if nums[r] < pivot {
// 			nums[l], nums[r] = nums[r], nums[l]
// 			l++
// 		}
// 		r++
// 	}
// 	nums[l], nums[end] = nums[end], nums[l]
// 	quickSort(nums, start, l-1)
// 	quickSort(nums, l+1, end)
// }

// func quickSort(nums []int) {
// 	if len(nums) <= 1 {
// 		return
// 	}
// 	pivot := nums[len(nums)-1]
// 	l, r := 0, 0
// 	for r < len(nums)-1 {
// 		if nums[r] < pivot {
// 			nums[l], nums[r] = nums[r], nums[l]
// 			l++
// 		}
// 		r++
// 	}
// 	nums[l], nums[len(nums)-1] = nums[len(nums)-1], nums[l]
// 	quickSort(nums[:l])
// 	quickSort(nums[l+1:])
// }

// func mergeSort(nums []int) []int {
// 	if len(nums) <= 1 {
// 		return nums
// 	}
// 	left := mergeSort(nums[:len(nums)/2])
// 	right := mergeSort(nums[len(nums)/2:])
// 	return merge(left, right)
// }

// func merge(left []int, right []int) []int {
// 	res := make([]int, 0)
// 	l, r := 0, 0
// 	for l < len(left) && r < len(right) {
// 		if left[l] < right[r] {
// 			res = append(res, left[l])
// 			l++
// 		} else {
// 			res = append(res, right[r])
// 			r++
// 		}
// 	}
// 	res = append(res, left[l:]...)
// 	res = append(res, right[r:]...)
// 	return res
// }

// func shellSort(nums []int) []int {
// 	gap := 1
// 	for gap < len(nums) {
// 		gap = gap*5 + 1
// 	}
// 	for ; gap > 0; gap /= 5 {
// 		for i := gap; i < len(nums); i++ {
// 			temp := nums[i]
// 			j := i - gap
// 			for ; j >= 0 && nums[j] > temp; j -= gap {
// 				nums[j+gap] = nums[j]
// 			}
// 			nums[j+gap] = temp
// 		}
// 	}
// 	return nums
// }

func insertSort(nums []int) []int {
	for i := 1; i < len(nums); i++ {
		temp := nums[i]
		j := i - 1
		for ; j >= 0; j-- {
			if nums[j] > temp {
				nums[j+1] = nums[j]
			} else {
				break
			}
		}
		nums[j+1] = temp
	}
	return nums
}

// func chooseSort(nums []int) []int {
// 	for i := 0; i < len(nums); i++ {
// 		index := i
// 		for j := i + 1; j < len(nums); j++ {
// 			if nums[j] < nums[index] {
// 				index = j
// 			}
// 		}
// 		nums[i], nums[index] = nums[index], nums[i]
// 	}
// 	return nums
// }

// func bubbleSort(nums []int) ([]int, int) {
// 	k := 0
// 	cnt := 0
// 	for i := 0; i < len(nums); i++ {
// 		flag := false
// 		cnt++
// 		for j := 0; j < len(nums)-i-1; j++ {
// 			if nums[j] > nums[j+1] {
// 				flag = true
// 				nums[j], nums[j+1] = nums[j+1], nums[j]
// 				// k = j
// 			}
// 		}
// 		if !flag {
// 			return nums, cnt
// 		}
// 	}
// 	return nums, cnt
// }

// func maximumInvitations(g []int) int { // favorite 就是内向基环森林 g
// 	n := len(g)
// 	rg := make([][]int, n) // g 的反图
// 	deg := make([]int, n)  // g 上每个节点的入度，例如对于点i，有多少个点j是指向点i
// 	for v, w := range g {
// 		rg[w] = append(rg[w], v)
// 		deg[w]++
// 	}

// 	// 拓扑排序，剪掉 g 上的所有树枝
// 	q := []int{}
// 	for i, d := range deg { //首先先找出没有入度的点
// 		if d == 0 {
// 			q = append(q, i)
// 		}
// 	}
// 	for len(q) > 0 {
// 		v := q[0]
// 		q = q[1:]
// 		w := g[v] // v 只有一条出边
// 		if deg[w]--; deg[w] == 0 { //将没有入度的点x所指向的y，切掉x后y的入度就--，如果当前的入度为0，则说明y也是属于树枝
// 			//对于基环的节点一定有一个入度
// 			q = append(q, w)
// 		}
// 	}
// 	//到这一步，deg上不为0的元素的数量就是基环上元素的数量
// 	// 通过反图 rg 寻找树枝上最深的链
// 	var rdfs func(int) int
// 	rdfs = func(v int) int {
// 		maxDepth := 1
// 		for _, w := range rg[v] {
// 			if deg[w] == 0 { // 树枝上的点在拓扑排序后，入度均为 0
// 				maxDepth = max(maxDepth, rdfs(w)+1)
// 			}
// 		}
// 		return maxDepth
// 	}

// 	maxRingSize, sumChainSize := 0, 0
// 	for i, d := range deg { //遍历入度的deg数组
// 		if d <= 0 { //表示是树枝
// 			continue
// 		}
// 		// 遍历基环上的点（拓扑排序后入度大于 0）
// 		deg[i] = -1
// 		ringSize := 1
// 		for v := g[i]; v != i; v = g[v] { //这里的作用用于获取deg上 > 0的点组成的基环的长度，同时将环上的点的入度标记为 -1
// 			deg[v] = -1 // 将基环上的点的入度标记为 -1，避免重复访问
// 			ringSize++
// 		}
// 		if ringSize == 2 { // 基环大小为 2
// 			sumChainSize += rdfs(i) + rdfs(g[i]) // 累加两条最长链的长度，
// 		} else {
// 			maxRingSize = max(maxRingSize, ringSize) // 取所有基环的最大值
// 		}
// 	}
// 	return max(maxRingSize, sumChainSize)
// }

// func main() {
// 	dur := 1 * time.Second
// 	t := time.NewTicker(dur)
// 	<-t.C
// 	for {
// 		select {
// 		case <-t.C:
// 			fmt.Println()
// 		}
// 	}
// }

// func possibleToStamp(grid [][]int, stampHeight int, stampWidth int) bool {
// 	m, n := len(grid), len(grid[0])
// 	preSum := make([][]int, m+1) //二维前缀和数组, 长度上+1是为了不用对 i == 0时进行特殊处理，这个数组的目的用于判断
// 	//这个区域是否有被占据点，也就是区域和是否大于1
// 	preSum[0] = make([]int, n+1)
// 	diff := make([][]int, m+1) //差分数组，用于恢复出计数数组，某个点为1表示右下角所有点都 + 1
// 	diff[0] = make([]int, n+1)

// 	//生成二维前缀和数组，用于快速得到某个区域的和
// 	for i := 0; i < m; i++ {
// 		preSum[i+1] = make([]int, n+1)
// 		for j := 0; j < n; j++ {
// 			preSum[i+1][j+1] = preSum[i+1][j] + preSum[i][j+1] - preSum[i][j] + grid[i][j]
// 		}
// 		diff[i+1] = make([]int, n+1)
// 	}

// 	for i := 0; i < m; i++ {
// 		for j := 0; j < n; j++ {
// 			if grid[i][j] != 0 {
// 				continue
// 			}
// 			x := i + stampHeight //边界
// 			y := j + stampWidth  //边界，这里相当于 x - 1 < m
// 			if x <= m && y <= n {
// 				sum := preSum[x][y] + preSum[i][j] - preSum[x][j] - preSum[i][y] //得到这个区域的和判断是否大于 == 0
// 				//如果 == 0表示没有不可占据点
// 				if sum == 0 {
// 					diff[i][j]++ //差分数组i,j点++，那么以i,j为左上角的右下方区域的值都会+1，而我们想要的是到x,y这个区域
// 					//因此需要对应的--1
// 					diff[i][y]--
// 					diff[x][j]--
// 					diff[x][y]++
// 				}
// 			}
// 		}
// 	}

// 	//从二维差分数组中恢复出每个点的cnt值，表示该点覆盖的次数
// 	newPreSum := make([][]int, m+1)
// 	newPreSum[0] = make([]int, n+1)
// 	for i := 0; i < m; i++ {
// 		newPreSum[i+1] = make([]int, n+1)
// 		for j := 0; j < n; j++ {
// 			newPreSum[i+1][j+1] = newPreSum[i][j+1] + newPreSum[i+1][j] - newPreSum[i][j] + diff[i][j]
// 			if newPreSum[i+1][j+1] == 0 && grid[i][j] == 0 { //判断该点是不被占据点同时被计数值==0表示没有被邮票覆盖则false
// 				return false
// 			}
// 		}
// 	}

// 	return true
// }

// func possibleToStamp(grid [][]int, stampHeight int, stampWidth int) bool {
// 	m, n := len(grid), len(grid[0])
// 	preSum := make([][]int, m+1)
// 	diff := make([][]int, m) //差分数组

// 	for i := 0; i < m; i++ {
// 		diff[i] = make([]int, n)
// 	}

// 	preSum[0] = make([]int, n+1)
// 	for i := 0; i < m; i++ {
// 		preSum[i+1] = make([]int, n+1)
// 		for j := 0; j < n; j++ {
// 			preSum[i+1][j+1] = preSum[i+1][j] + preSum[i][j+1] - preSum[i][j] + grid[i][j]
// 		}
// 	}

// 	for i := 0; i < m; i++ {
// 		for j := 0; j < n; j++ {
// 			if grid[i][j] == 0 {
// 				continue
// 			}
// 			x := i + stampHeight - 1
// 			y := j + stampWidth - 1
// 			if x < m && y < n {
// 				sum := preSum[x+1][y+1] + preSum[i][j] - preSum[x+1][j] - preSum[i][y+1]
// 				if sum == 0 {
// 					diff[i][j]++
// 					diff[i][y+1]--
// 					diff[x+1][j]--
// 					diff[x+1][y+1]++
// 				}
// 			}
// 		}
// 	}

// 	newPreSum := make([][]int, m+1)
// 	newPreSum[0] = make([]int, n+1)
// 	for i := 0; i < m; i++ {
// 		for j := 0; j < n; j++ {
// 			newPreSum[i+1] = make([]int, n)
// 			newPreSum[i+1][j+1] = newPreSum[i][j+1] + newPreSum[i+1][j] - newPreSum[i][j] + diff[i][j]
// 		}
// 	}
// 	for i := 0; i < m; i++ {
// 		for j := 0; j < n; j++ {
// 			if grid[i][j] == 0 && newPreSum[i+1][j+1] == 0 {
// 				return false
// 			}
// 		}
// 	}
// 	return true
// }

// func possibleToStamp(grid [][]int, stampHeight, stampWidth int) bool {
// 	m, n := len(grid), len(grid[0])
// 	sum := make([][]int, m+1)
// 	sum[0] = make([]int, n+1)
// 	diff := make([][]int, m+1)
// 	diff[0] = make([]int, n+1)
// 	for i, row := range grid {
// 		sum[i+1] = make([]int, n+1)
// 		for j, v := range row { // grid 的二维前缀和
// 			sum[i+1][j+1] = sum[i+1][j] + sum[i][j+1] - sum[i][j] + v
// 		}
// 		diff[i+1] = make([]int, n+1)
// 	}

// 	for i, row := range grid {
// 		for j, v := range row {
// 			if v == 0 {
// 				x, y := i+stampHeight, j+stampWidth // 注意这是矩形右下角横纵坐标都 +1 后的位置
// 				if x <= m && y <= n && sum[x][y]-sum[x][j]-sum[i][y]+sum[i][j] == 0 {
// 					diff[i][j]++
// 					diff[i][y]--
// 					diff[x][j]--
// 					diff[x][y]++ // 更新二维差分
// 				}
// 			}
// 		}
// 	}

// 	// 还原二维差分矩阵对应的计数矩阵，这里用滚动数组实现
// 	cnt := make([]int, n+1)
// 	pre := make([]int, n+1)
// 	for i, row := range grid {
// 		for j, v := range row {
// 			cnt[j+1] = cnt[j] + pre[j+1] - pre[j] + diff[i][j]
// 			if cnt[j+1] == 0 && v == 0 {
// 				return false
// 			}
// 		}
// 		cnt, pre = pre, cnt
// 	}
// 	return true
// }

// type ReuseObj struct{}
// type ObjPool struct {
// 	Objs chan *ReuseObj
// }

// func NewObjPool(size int) *ObjPool {
// 	r := &ObjPool{
// 		Objs: make(chan *ReuseObj, size),
// 	}
// 	for i := 0; i < size; i++ {
// 		r.Objs <- &ReuseObj{}
// 	}
// 	return r
// }

// func (pool *ObjPool) Get(t time.Duration) (*ReuseObj, error) {
// 	for {
// 		select {
// 		case obj := <-pool.Objs:
// 			return obj, nil
// 		case <-time.After(t):
// 			return nil, errors.New("tiem out")
// 		}
// 	}
// }

// func (pool *ObjPool) Release(obj *ReuseObj) error {
// 	for {
// 		select {
// 		case pool.Objs <- obj:
// 			return nil
// 		default:
// 			return errors.New("time out")
// 		}
// 	}
// }

// listen, _ := net.Listen("tcp", "0.0.0.0:8008")
// cnt := 0
// maxcnt := 100
// go func() {
// 	timer := time.NewTimer(1 * time.Second)
// 	for {
// 		select {
// 		case <-timer.C:
// 			cnt = 0
// 			timer.Reset(1 * time.Second)
// 		}
// 	}
// }()
// for {
// 	conn, err := listen.Accept()
// 	if err != nil {
// 		continue
// 	}
// 	go func(conn net.Conn) {
// 		defer conn.Close()
// 		for {
// 			var buf [128]byte
// 			n, _ := conn.Read(buf[:])
// 			if cnt > maxcnt {
// 				continue
// 			}
// 			cnt++
// 			fmt.Println(string(buf[:n]))
// 		}
// 	}(conn)
// }
// func solve(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	res := 0
// 	l, r := 0, len(nums)-1
// 	for l <= r {
// 		if nums[l] < nums[r] {
// 			l++
// 		} else if nums[l] == nums[r] {
// 			l++
// 			r--
// 		} else {
// 			r--
// 		}
// 		res++
// 	}
// 	return res
// }

// func DeleteItem(nums []int) int {
// 	indexs := make([]struct{ x, y int }, len(nums)+2) //x表示连续的1值，y表示删除一个1以后的连续1值
// 	res := 0
// 	for i := 2; i < len(indexs); i++ {
// 		if nums[i-2] == 0 {
// 			continue
// 		}
// 		indexs[i].y = max(indexs[i-2].x, indexs[i-1].y) + 1 //表示删除过一个值的最大值
// 		indexs[i].x = indexs[i-1].x + 1
// 		res = max(res, max(indexs[i].x, indexs[i].y))
// 	}
// 	if res == len(nums) {
// 		return res - 1
// 	}
// 	return res
// }

// func wordCount(startWords []string, targetWords []string) int {
// 	//将targetWords中的每个字符串转换为bits去表示，26位每一位表示对应的字符是否存在
// 	//对于targetWords中的每个字符串都遍历startWords,从中选出一个字符串与该字符串只是相差一个字符串，则说明可以进行转换
// 	// tgmap := make(map[string]int)
// 	res := 0
// 	swmap := make(map[int]bool)
// 	for _, word := range startWords {
// 		num := 0
// 		for _, ch := range word {
// 			num |= 1 << (ch - 'a')
// 		}
// 		swmap[num] = true
// 	}
// 	// fmt.Println(swmap)
// 	for _, word := range targetWords {
// 		num := 0
// 		for _, ch := range word {
// 			num |= 1 << (ch - 'a')
// 		}
// 		for _, ch := range word {
// 			nnem := num
// 			nnem ^= 1 << (ch - 'a')
// 			if _, ok := swmap[nnem]; ok {
// 				res++
// 				break
// 			}
// 		}
// 	}
// 	return res
// }

// func maxRunTime(n int, batteries []int) int64 {
// 	if n > len(batteries) {
// 		return 0
// 	}
// 	h := &IHeap{}
// 	(*h) = append((*h), batteries...)
// 	heap.Init(h)
// 	var res int64
// 	for {
// 		for i := 0; i < n; i++ {
// 			val := heap.Pop(h).(int)
// 			val--
// 			if val < 0 {
// 				return res
// 			}
// 			heap.Push(h, val)
// 		}
// 		res++
// 	}
// 	return res
// }

// type IHeap []int

// func (h IHeap) Len() int { return len(h) }

// //这个意思是数组从左到右按照从大到小
// func (h IHeap) Less(i, j int) bool { return h[i] < h[j] }
// func (h IHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

// func (h *IHeap) Push(x interface{}) {
// 	*h = append(*h, x.(int))
// }

// func (h *IHeap) Pop() interface{} {
// 	old := *h
// 	x := old[len(old)-1]
// 	*h = old[0 : len(old)-1]
// 	return x
// }

// type minHeap struct{ sort.IntSlice }

// func (h *minHeap) Pop() interface{} {
// 	val := h.IntSlice[len(h.IntSlice)-1]
// 	h.IntSlice = h.IntSlice[:len(h.IntSlice)-1]
// 	return val
// }
// func (h *minHeap) Push(x interface{}) {
// 	h.IntSlice = append(h.IntSlice, x.(int))
// }

// type hp []cell

// func (h hp) Len() int            { return len(h) }
// func (h hp) Less(i, j int) bool  { return h[i].h < h[j].h }
// func (h hp) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
// func (h *hp) Push(v interface{}) { *h = append(*h, v.(cell)) }
// func (h *hp) Pop() interface{}   { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }
// func trapRainWater(heightMap [][]int) (ans int) {
// 	m, n := len(heightMap), len(heightMap[0])
// 	if m <= 2 || n <= 2 {
// 		return
// 	}

// 	vis := make([][]bool, m)
// 	for i := range vis {
// 		vis[i] = make([]bool, n)
// 	}
// 	h := &hp{}
// 	for i, row := range heightMap {
// 		for j, v := range row {
// 			if i == 0 || i == m-1 || j == 0 || j == n-1 {
// 				heap.Push(h, cell{v, i, j})
// 				vis[i][j] = true
// 			}
// 		}
// 	}

// 	dirs := []int{-1, 0, 1, 0, -1}
// 	for h.Len() > 0 {
// 		cur := heap.Pop(h).(cell)
// 		for k := 0; k < 4; k++ {
// 			nx, ny := cur.x+dirs[k], cur.y+dirs[k+1]
// 			if 0 <= nx && nx < m && 0 <= ny && ny < n && !vis[nx][ny] {
// 				if heightMap[nx][ny] < cur.h {
// 					ans += cur.h - heightMap[nx][ny]
// 				}
// 				vis[nx][ny] = true
// 				heap.Push(h, cell{max(heightMap[nx][ny], cur.h), nx, ny})
// 			}
// 		}
// 	}
// 	return
// }

// type cell struct{ h, x, y int }
// type hp []cell

// func (h hp) Len() int            { return len(h) }
// func (h hp) Less(i, j int) bool  { return h[i].h < h[j].h }
// func (h hp) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
// func (h *hp) Push(v interface{}) { *h = append(*h, v.(cell)) }
// func (h *hp) Pop() interface{}   { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }

// var dirs = []struct{ x, y int }{{-1, 0}, {1, 0}, {0, -1}, {0, 1}}

// func highestRankedKItems(grid [][]int, pricing, start []int, k int) (ans [][]int) {
// 	m, n := len(grid), len(grid[0])
// 	low, high := pricing[0], pricing[1]
// 	sx, sy := start[0], start[1]
// 	vis := make([][]bool, m)
// 	for i := range vis {
// 		vis[i] = make([]bool, n)
// 	}
// 	vis[sx][sy] = true
// 	q := [][]int{{sx, sy}}
// 	for len(q) > 0 { // 分层 BFS
// 		// 此时 q 内所有元素到起点的距离均相同，因此按照题目中的第 2~4 关键字排序后，就可以将价格在 [low,high] 内的位置加入答案
// 		sort.Slice(q, func(i, j int) bool {
// 			ax, ay, bx, by := q[i][0], q[i][1], q[j][0], q[j][1]
// 			pa, pb := grid[ax][ay], grid[bx][by]
// 			return pa < pb || pa == pb && (ax < bx || ax == bx && ay < by)
// 		})
// 		l := sort.Search(len(q), func(i int) bool { return grid[q[i][0]][q[i][1]] >= low })
// 		r := sort.Search(len(q), func(i int) bool { return grid[q[i][0]][q[i][1]] > high })
// 		ans = append(ans, q[l:r]...)
// 		if len(ans) >= k {
// 			return ans[:k]
// 		}
// 		tmp := q
// 		q = nil
// 		for _, p := range tmp {
// 			for _, d := range dirs {
// 				if x, y := p[0]+d.x, p[1]+d.y; 0 <= x && x < m && 0 <= y && y < n && !vis[x][y] && grid[x][y] != 0 {
// 					vis[x][y] = true
// 					q = append(q, []int{x, y})
// 				}
// 			}
// 		}
// 	}
// 	return
// }

// type pair struct{ x, y int }

// var dirs = []pair{{-1, 0}, {1, 0}, {0, -1}, {0, 1}}

// func highestPeak(isWater [][]int) [][]int {
// 	m, n := len(isWater), len(isWater[0])
// 	ans := make([][]int, m)
// 	for i := range ans {
// 		ans[i] = make([]int, n)
// 		for j := range ans[i] {
// 			ans[i][j] = -1 // -1 表示该格子尚未被访问过
// 		}
// 	}
// 	q := []pair{}
// 	for i, row := range isWater {
// 		for j, water := range row {
// 			if water == 1 { // 将所有水域入队
// 				ans[i][j] = 0
// 				q = append(q, pair{i, j})
// 			}
// 		}
// 	}
// 	for len(q) > 0 {
// 		p := q[0]
// 		q = q[1:]
// 		for _, d := range dirs {
// 			if x, y := p.x+d.x, p.y+d.y; 0 <= x && x < m && 0 <= y && y < n && ans[x][y] == -1 {
// 				ans[x][y] = ans[p.x][p.y] + 1
// 				q = append(q, pair{x, y})
// 			}
// 		}
// 	}
// 	return ans
// }

// func minimumDifference(nums []int) int64 {
// 	m := len(nums)
// 	n := m / 3

// 	//初始化大顶堆和小顶堆
// 	minhq := minHeap{nums[m-n:]}
// 	maxhq := maxHeap{nums[:n]}
// 	heap.Init(minhq)
// 	heap.Init(maxhq)
// 	sumMax := make([]int, m-n+1) //用于保存从最右边的n个值一直到最左边每个窗口内的最大值，
// 	//sunMax[i]表示从nums[i:]这段区间内最大的n个数的和
// 	sum := 0
// 	for i := m - n; i < m; i++ {
// 		sum += nums[i]
// 	}
// 	sumMax[m-n] = sum
// 	for i := m - n - 1; i >= n; i-- {
// 		if nums[i] > minhq.IntSlice[0] {
// 			sum = sum - minhq.IntSlice[0] + nums[i]
// 			minhq.IntSlice[0] = nums[i]
// 			heap.Fix(minhq, 0)
// 		}
// 		sumMax[i] = sum
// 	}

// 	sumMin := make([]int, m-n+1)
// 	sum = 0
// 	for i := 0; i < n; i++ {
// 		sum += nums[i]
// 	}
// 	sumMin[n-1] = sum
// 	for i := n; i < m-n; i++ {
// 		if nums[i] < maxhq.IntSlice[0] {
// 			sum = sum - maxhq.IntSlice[0] + nums[i]
// 			maxhq.IntSlice[0] = nums[i]
// 			heap.Fix(maxhq, 0)
// 		}
// 		sumMin[i] = sum
// 	}
// 	fmt.Println(sumMax)
// 	res := math.MaxInt32
// 	for i := n - 1; i < m-n; i++ {
// 		res = min(res, sumMin[i]-sumMax[i+1])
// 	}
// 	return int64(res)
// }

// //这里不用实现push和pop是因为我们在程序中没有使用heap.Push或者heap.Pop功能，因此用不到这两个函数
// type minHeap struct{ sort.IntSlice }

// func (minHeap) Push(interface{})     {}
// func (minHeap) Pop() (_ interface{}) { return }

// type maxHeap struct{ sort.IntSlice }

// func (h maxHeap) Less(i, j int) bool { return h.IntSlice[i] > h.IntSlice[j] }
// func (maxHeap) Push(interface{})     {}
// func (maxHeap) Pop() (_ interface{}) { return }

// type minHeap struct{ sort.IntSlice } //包含sort.IntSlice就是一个存在默认的实现

// func (minHeap) Push(interface{})     {}
// func (minHeap) Pop() (_ interface{}) { return }

//type maxHeap struct{ sort.IntSlice } //大顶堆

// func (h maxHeap) Less(i, j int) bool { return h.IntSlice[i] > h.IntSlice[j] }
// func (maxHeap) Push(interface{})     {}
// func (maxHeap) Pop() (_ interface{}) { return }

// func minimumDifference(nums []int) int64 {
// 	m := len(nums)
// 	n := m / 3                   //n == 2
// 	minPQ := minHeap{nums[m-n:]} //minPQ包含最后的n个元素
// 	heap.Init(&minPQ)            //初始化这个最小堆，nums[m-n:]的最小值在nums[m - n]的位置
// 	sum := 0
// 	for _, v := range nums[m-n:] { //对最后的n个元素求和
// 		sum += v
// 	}

// 	sufMax := make([]int, m-n+1) //长度为2n + 1,
// 	sufMax[m-n] = sum            //2n
// 	for i := m - n - 1; i >= n; i-- {
// 		if v := nums[i]; v > minPQ.IntSlice[0] {
// 			sum += v - minPQ.IntSlice[0]
// 			minPQ.IntSlice[0] = v
// 			heap.Fix(&minPQ, 0) //重新建立堆索引
// 		}
// 		sufMax[i] = sum
// 	}

// 	maxPQ := maxHeap{nums[:n]}
// 	heap.Init(&maxPQ)
// 	preMin := 0 // 前缀最小和
// 	for _, v := range nums[:n] {
// 		preMin += v
// 	}
// 	ans := preMin - sufMax[n]
// 	for i := n; i < m-n; i++ {
// 		if v := nums[i]; v < maxPQ.IntSlice[0] {
// 			preMin += v - maxPQ.IntSlice[0]
// 			maxPQ.IntSlice[0] = v
// 			heap.Fix(&maxPQ, 0)
// 		}
// 		ans = min(ans, preMin-sufMax[i+1])
// 	}
// 	return int64(ans)
// }

// type minHeap struct{ sort.IntSlice } //包含sort.IntSlice就是一个存在默认的实现

// func (minHeap) Push(interface{})     {}
// func (minHeap) Pop() (_ interface{}) { return }

//type maxHeap struct{ sort.IntSlice } //大顶堆

// func (h maxHeap) Less(i, j int) bool { return h.IntSlice[i] > h.IntSlice[j] }
// func (maxHeap) Push(interface{})     {}
// func (maxHeap) Pop() (_ interface{}) { return }

// func minimumSum(num int) int {
// 	s := strconv.FormatInt(int64(num), 10)
// 	nums := []byte(s)
// 	sort.Slice(nums, func(i, j int) bool { return nums[i]-'0' < nums[j]-'0' })
// 	return int(nums[0]-'0')*10 + int(nums[3]-'0') + int(nums[1]-'0')*10 + int(nums[2]-'0')
// }

// type Bitset struct {
// 	bits []byte
// 	cnt  int
// 	size int
// }

// func Constructor(size int) Bitset {
// 	str := ""
// 	for i := 0; i < size; i++ {
// 		str += "0"
// 	}
// 	b := Bitset{
// 		bits: []byte(str),
// 		cnt:  0,
// 		size: size,
// 	}
// 	return b
// }

// func (this *Bitset) Fix(idx int) {
// 	if this.bits[idx] == '0' {
// 		this.bits[idx] = '1'
// 		this.cnt++
// 	}
// }

// func (this *Bitset) Unfix(idx int) {
// 	if this.bits[idx] == '1' {
// 		this.bits[idx] = '0'
// 		this.cnt--
// 	}

// }

// func (this *Bitset) Flip() {
// 	for i := 0; i < len(this.bits); i++ {
// 		if this.bits[i] == '1' {
// 			this.bits[i] = '0'
// 			this.cnt--
// 		} else {
// 			this.bits[i] = '1'
// 			this.cnt++
// 		}
// 	}
// }

// func (this *Bitset) All() bool {
// 	return this.cnt == this.size
// }

// func (this *Bitset) One() bool {
// 	return this.cnt >= 1
// }

// func (this *Bitset) Count() int {
// 	return this.cnt
// }

// func (this *Bitset) ToString() string {
// 	return string(this.bits)
// }

// func smallestNumber(num int64) int64 {
// 	if num == 0 {
// 		return 0
// 	}
// 	flag := true //true是正数
// 	if num < 0 {
// 		flag = false
// 		num = -1 * num
// 	}
// 	nums := make([]int, 0)
// 	val := num
// 	for val != 0 {
// 		nums = append(nums, int(val%10))
// 		val = val / 10
// 	}
// 	sort.Ints(nums)
// 	var res int64
// 	if flag {
// 		i := 0
// 		cnt := 1
// 		for nums[i] == 0 {
// 			i++
// 			cnt *= 10
// 		}
// 		res = int64(nums[i] * cnt)
// 		i++
// 		for ; i < len(nums); i++ {
// 			res = res*10 + int64(nums[i])
// 		}
// 		return res
// 	} else {
// 		for i := len(nums) - 1; i >= 0; i-- {
// 			res = res*10 + int64(nums[i])
// 		}
// 		return -1 * res
// 	}

// 	// return res
// }

// func sortEvenOdd(nums []int) []int {
// 	if len(nums) < 2 {
// 		return nums
// 	}
// 	n1 := make([]int, 0) //偶数
// 	n2 := make([]int, 0) //奇数
// 	for i := 0; i < len(nums); i += 2 {
// 		n1 = append(n1, nums[i])
// 	}
// 	for i := 1; i < len(nums); i += 2 {
// 		n2 = append(n2, nums[i])
// 	}
// 	sort.Ints(n1)
// 	sort.Slice(n2, func(i, j int) bool {
// 		return n2[i] > n2[j]
// 	})
// 	res := make([]int, 0)
// 	i := 0
// 	for i < len(n1) && i < len(n2) {
// 		res = append(res, n1[i])
// 		res = append(res, n2[i])
// 		i++
// 	}
// 	res = append(res, n1...)
// 	res = append(res, n2...)
// 	return res
// }

// func pivotArray(nums []int, pivot int) []int {
// 	if len(nums) == 0 || len(nums) < 2 {
// 		return nums
// 	}
// 	x := make([]int, 0)
// 	mid := make([]int, 0)
// 	d := make([]int, 0)
// 	res := make([]int, 0)
// 	for i := 0; i < len(nums); i++ {
// 		if nums[i] < pivot {
// 			x = append(x, nums[i])
// 		} else if nums[i] > pivot {
// 			d = append(d, nums[i])
// 		} else {
// 			mid = append(mid, nums[i])
// 		}
// 	}
// 	res = append(res, x...)
// 	res = append(res, mid...)
// 	res = append(res, d...)
// 	return res
// }

// func minimumSum(num int) int {
// 	nums := make([]int, 4)
// 	for i := 0; i < 4; i++ {
// 		nums[i] = num % 10
// 		num = num / 10
// 	}
// 	sort.Ints(nums)
// 	num1 := nums[0]*10 + nums[3]
// 	num2 := nums[1]*10 + nums[2]
// 	return num1 + num2
// }

// func subStrHash(s string, power, mod, k, hashValue int) (ans string) {
// 	hash, p := 0, 1
// 	i, n := len(s)-1, len(s)
// 	for ; i >= n-k; i-- {
// 		hash = (hash*power + int(s[i]&31)) % mod // 用秦九韶算法计算 s[n-k:] 的哈希值
// 		p = p * power % mod
// 	}
// 	if hash == hashValue {
// 		ans = s[n-k:]
// 	}
// 	for ; i >= 0; i-- { // 倒着向前滑动窗口
// 		hash = (hash*power + int(s[i]&31) + mod - p*int(s[i+k]&31)%mod) % mod // 计算新哈希值
// 		if hash == hashValue {
// 			ans = s[i : i+k]
// 		}
// 	}
// 	return
// }

// func subStrHash(s string, power int, modulo int, k int, hashValue int) string {
// 	if len(s) < k {
// 		return ""
// 	}
// 	str := ""
// 	value, p := 0, 1
// 	for i := len(s) - 1; i >= 0; i-- {
// 		if i >= len(s)-k {
// 			value = (int(s[i]-'a'+1) + (power * value)) % modulo
// 			p = p * power % modulo
// 			str = string(s[i]) + str
// 			continue
// 		}
// 		if value == hashValue {
// 			return str
// 		}
// 		value = (value*power + int(s[i]-'a'+1) - int(s[i+k]-'a'+1)*p%modulo) % modulo
// 		str = string(s[i]) + str[:len(str)-1]
// 	}
// 	if value == hashValue {
// 		return str
// 	}
// 	return ""
// }

//2_4腾讯真题
// func IsReverseNum(num int) string{
//     if num == 0{
//         return "Yes"
//     }
//     if num < 0{
//         num = -1 * num
//     }
//     value := 1
//     temp := num
//     for temp >= 10{
//         value *= 10
//         temp /= 10
//     }
//     for num != 0{
//         if num % 10 != num / value{
//             return "No"
//         }
//         num = (num % value) / 10
//         value /= 100
//     }
//     return "Yes"
// }
// func subStrHash(s string, prime int, mod int, k int, hashValue int) (ans string) {
// 	powP := make([]int, len(s)+1)
// 	powP[0] = 1
// 	preHash := make([]int, len(s)+1)
// 	_tmp := []byte(s)
// 	for i, n := 0, len(_tmp); i < n/2; i++ {
// 		_tmp[i], _tmp[n-1-i] = _tmp[n-1-i], _tmp[i]
// 	}
// 	rev := string(_tmp)
// 	for i, b := range rev {
// 		powP[i+1] = powP[i] * prime % mod
// 		preHash[i+1] = (preHash[i]*prime + int(b-'a'+1)) % mod
// 	}

// 	// 计算子串 s[l:r] 的哈希
// 	subHash := func(l, r int) int { return ((preHash[r]-preHash[l]*powP[r-l])%mod + mod) % mod }

// 	for i := len(s); i >=k; i-- {
// 		if subHash(i-k,i) == hashValue {
// 			j := len(s)-i
// 			return s[j:j+k]
// 		}
// 	}

// 	//panic(-1)
// 	return
// }
// func subStrHash(s string, power int, modulo int, k int, hashValue int) string {
// 	if s == ""{
// 		return ""
// 	}
// 	power = power % hashValue
// 	// num := power / hashValue
// 	// modulo = modulo % hashValue
// 	for i := 0; i < len(s); i++{
// 		str := ""
// 		var cnt float64
// 		var value int64
// 		for j := i; j < len(s); j++{
// 			// k := int(float64(s[j] - 'a' + 1) * (math.Pow(float64(power),cnt))) % math.MaxInt32
// 			value = value + int64(s[j] - 'a' + 1) * int64(math.Pow(float64(power),cnt))
// 			str += string(s[j])
// 			fmt.Println(value,str,(value  % int64(modulo)))
// 			if len(str) == k && int64(value) % int64(modulo) == int64(hashValue) {
// 				return str
// 			}
// 			if len(str) >= k{
// 				break
// 			}
// 			// value = value % math.MaxInt64
// 			cnt++
// 		}
// 	}
// 	return ""
// }

// func maxScoreIndices(nums []int) []int {
// 	if len(nums) == 0{
// 		return nil
// 	}
// 	res := make([]int, 0)
// 	value := math.MinInt32
// 	left := make([]int, len(nums) + 1)
// 	right := make([]int, len(nums) + 1)
// 	for i := 1; i < len(left); i++{
// 		if nums[i - 1] == 0{
// 			left[i] += 1 + left[i - 1]
// 		}else{
// 			left[i] += left[i - 1]
// 		}
// 	}
// 	for i := len(right) - 2; i >= 0; i--{
// 		right[i] += nums[i] + right[i + 1]
// 	}
// 	// fmt.Println(left, right)
// 	for i := 0; i < len(left); i++{
// 		// fmt.Println(left[i] + right[i], i, res)
// 		if left[i] + right[i] > value{
// 			value = left[i] + right[i]
// 			res = []int{i}
// 		}else if left[i] + right[i] == value{
// 			res = append(res, i)
// 		}
// 	}
// 	return res
// }
// func findFinalValue(nums []int, original int) int {
// 	if len(nums) == 0{
// 		return 0
// 	}
// 	mmap := make(map[int]int)
// 	for i := 0; i < len(nums); i++{
// 		mmap[nums[i]] = 1
// 	}
// 	for{
// 		if _, ok := mmap[original];ok{
// 			original = 2 * original
// 		}else{
// 			return original
// 		}
// 	}
// 	return original
// }
// func kkk(nums []int){
// 	nums = append(nums,4)
// 	fmt.Println("1,",nums)
// }
// func sortArray(nums []int) []int{
// 	if len(nums) == 0{
// 		return nums
// 	}
// 	n := len(nums)
// 	sortnums := append([]int{0},nums...)
// 	for i := n / 2; i >= 1; i--{
// 		sink(sortnums, i, n)
// 	}
// 	k := n
// 	for k > 1{
// 		sortnums[1], sortnums[k] = sortnums[k], sortnums[1]
// 		k--
// 		sink(sortnums, 1, k)
// 	}
// 	return sortnums[1:]
// }

// func sink(nums []int, index int, n int){
// 	for 2 * index <= n{
// 		j := 2 * index  //k的左节点
// 		if j + 1 <= n && nums[j + 1] < nums[j] { //k的右节点，选择左右节点最大的那个
// 			j++
// 		}
// 		if nums[j] < nums[index]{ //与父节点进行判断，如果比父节点大则进行交换
// 			nums[j], nums[index] = nums[index], nums[j]
// 		}else{
// 			break
// 		}
// 		index = j //同时进一步下降判断
// 	}
// }

//         while (2 * k <= end) {
//             int j = 2 * k;
//             //找出子节点中最大或最小的那个
//             if (j + 1 <= end && nums[j + 1] > nums[j]) {
//                 j++;
//             }
//             if (nums[j] > nums[k]) {
//                 swap(nums, j, k);
//             } else {
//                 break;
//             }
//             k = j;
//         }
// class Solution {
//     public int[] sortArray(int[] nums) {

//         int len = nums.length;
//         int[] a = new int[len + 1];

//         for (int i = 0; i < nums.length; ++i) {
//             a[i+1] = nums[i];
//         }
//         //下沉建堆
//         for (int i = len/2; i >= 1; --i) {
//             sink(a,i,len);
//         }

//         int k = len;
//         //排序
//         while (k > 1) {
//             swap(a,1,k--);
//             sink(a,1,k);
//         }
//         for (int i = 1; i < len+1; ++i) {
//             nums[i-1] = a[i];
//         }
//         return nums;
//     }
//     public void sink (int[] nums, int k,int end) {
//         //下沉
//         while (2 * k <= end) {
//             int j = 2 * k;
//             //找出子节点中最大或最小的那个
//             if (j + 1 <= end && nums[j + 1] > nums[j]) {
//                 j++;
//             }
//             if (nums[j] > nums[k]) {
//                 swap(nums, j, k);
//             } else {
//                 break;
//             }
//             k = j;
//         }
//     }
//     public void swap (int nums[], int i, int j) {
//         int temp = nums[i];
//         nums[i] = nums[j];
//         nums[j] = temp;
//     }

// }

// func findOrder(numCourses int, prerequisites [][]int) []int {
// 	result := make([]int ,0)
// 	edges := make([][]int, numCourses)
// 	indeg := make([]int, numCourses)

// 	for _, v := range prerequisites{
// 		edges[v[1]] = append(edges[v[1]], v[0])
// 		indeg[v[0]]++
// 	}
// 	q := []int{}
// 	for i := 0; i < numCourses; i++{
// 		if indeg[i] == 0{
// 			q = append(q, i)
// 		}
// 	}
// 	for len(q) > 0{
// 		course := q[0]
// 		q = q[1:]
// 		result = append(result, course)
// 		for _, v := range edges[course]{
// 			indeg[v]--
// 			if indeg[v] == 0{
// 				q = append(q, v)
// 			}
// 		}
// 	}
// 	if len(result) != numCourses{
// 		return []int{}
// 	}
// 	return result
// }
// func findOrder(numCourses int, prerequisites [][]int) []int {
// 	if len(prerequisites) == 0{
// 		return nil
// 	}
// 	edges := make([][]int, numCourses)
// 	index := make([]int, numCourses) //用于表示该课程的状态，0表示未读取，1表示正在遍历，2表示已经完成
// 	result := make([]int, 0) //表示修读课程的顺序
// 	flag := true //表示是否出现环

// 	for _, p := range prerequisites{
// 		edges[p[0]] = append(edges[p[0]],p[1])
// 	}

// 	var dfs func(n int)
// 	dfs = func(n int){
// 		for _, v := range edges[n]{
// 			if index[v] == 1{
// 				flag = false
// 				return
// 			}else if index[v] == 0{
// 				index[v] = 1
// 				dfs(v)
// 				if !flag{
// 					return
// 				}
// 				index[v] = 2
// 				result = append(result, v)
// 			}
// 		}
// 	}
// 	for i := 0; i < len(edges); i++{
// 		if index[i] == 0{
// 			index[i] = 1
// 			dfs(i)
// 			index[i] = 2
// 			result = append(result, i)
// 		}
// 		if !flag {
// 			return nil
// 		}
// 	}
// 	return result
// }

// func findOrder(numCourses int, prerequisites [][]int) []int {
//     var (
//         edges = make([][]int, numCourses)
//         visited = make([]int, numCourses)
//         result []int
//         valid bool = true
//         dfs func(u int)
//     )

//     dfs = func(u int) {
//         visited[u] = 1
//         for _, v := range edges[u] {
//             if visited[v] == 0 {
//                 dfs(v)
//                 if !valid {
//                     return
//                 }
//             } else if visited[v] == 1 {
//                 valid = false
//                 return
//             }
//         }
//         visited[u] = 2
//         result = append(result, u)
//     }

//     for _, info := range prerequisites {
//         edges[info[1]] = append(edges[info[1]], info[0])
//     }

//     for i := 0; i < numCourses && valid; i++ {
//         if visited[i] == 0 {
//             dfs(i)
//         }
//     }
//     if !valid {
//         return []int{}
//     }
//     for i := 0; i < len(result)/2; i ++ {
//         result[i], result[numCourses-i-1] = result[numCourses-i-1], result[i]
//     }
//     return result
// }

// func networkDelayTime(times [][]int, n int, k int) (ans int) {
//     const inf = math.MaxInt64 / 2
//     g := make([][]int, n)
//     for i := range g {
//         g[i] = make([]int, n)
//         for j := range g[i] {
//             g[i][j] = inf
//         }
//     }
//     for _, t := range times { //将这个图转换为领接图
//         x, y := t[0]-1, t[1]-1
//         g[x][y] = t[2]
//     }

//     dist := make([]int, n) //给定节点与其他节点的路径最小值
//     for i := range dist {
//         dist[i] = inf
//     }
//     dist[k-1] = 0 //与自己的路径最小值为0
//     used := make([]bool, n) //false表示该节点属于非确定节点，true表示已确定节点
// 	//刚开始时是给定节点为确定节点，然后得到给定节点到所有相连节点的路径值，然后从未确定节点中找到路径值
// 	//最小的节点作为给定节点，同时更新所有的路径值，只有全部未确定节点都是确定节点
//     for i := 0; i < n; i++ {
//         x := -1
//         for y, u := range used {
//             if !u && (x == -1 || dist[y] < dist[x]) {
//                 x = y
//             }
//         }
//         used[x] = true
//         for y, time := range g[x] {
//             dist[y] = min(dist[y], dist[x]+time)
//         }
//     }

//     for _, d := range dist {
//         if d == inf {
//             return -1
//         }
//         ans = max(ans, d)
//     }
//     return
// }

// type unionFind struct{
// 	parent []int
// 	rank []int
// }

// func (this unionFind) find(x int) int{
// 	if this.parent[x] != x{
// 		this.parent[x] = this.find(this.parent[x])
// 	}
// 	return this.parent[x]
// }
// func (this unionFind)Union(x, y int) bool{
// 	vx,vy := this.find(x), this.find(y)
// 	if vx == vy{
// 		return false
// 	}
// 	if this.rank[x] < this.rank[y]{
// 		vx, vy = vy, vx
// 	}
// 	this.parent[vy] = vx
// 	this.rank[vy] += this.rank[vx]
// 	return true
// }
// func minCostConnectPoints(points [][]int) int {
// 	if len(points) == 0{
// 		return 0
// 	}
// 	n := len(points)
// 	res := 0
// 	union := unionFind{
// 		parent: make([]int, n),
// 		rank: make([]int, n),
// 	}
// 	for i := 0; i < n; i++{
// 		union.parent[i] = i
// 		union.rank[i] = 1
// 	}
// 	type point struct{x, y, length int}
// 	Ps := make([]point, 0)
// 	for i, p := range points{
// 		for j := i + 1; j < n; j++{
// 			p := point{i, j, TwoLen(p, points[j])}
// 			Ps = append(Ps, p)
// 		}
// 	}
// 	sort.Slice(Ps, func(i, j int) bool{
// 		return Ps[i][2] < ps[j][2]
// 	})
// 	l := n - 1

// 	for _,v := range Ps{
// 		if union.Union(v.x, v.y){
// 			res += v.length
// 			l--
// 			if l == 0{
// 				break
// 			}
// 		}
// 	}
// 	return res
// }

// func TwoLen(x, y []int)int{
// 	return abs(x[0] - y[0]) + abs(x[1] - y[1])
// }
// func abs(x int) int{
// 	if x < 0{
// 		return -1 * x
// 	}
// 	return x
// }
// type unionFind struct {
//     parent, rank []int
// }

// func newUnionFind(n int) *unionFind {
//     parent := make([]int, n)
//     rank := make([]int, n) //选择根节点时选择最大的那个，而不是随机选择
//     for i := range parent {
//         parent[i] = i
//         rank[i] = 1
//     }
//     return &unionFind{parent, rank}
// }

// func (uf *unionFind) find(x int) int {
//     if uf.parent[x] != x {
//         uf.parent[x] = uf.find(uf.parent[x])
//     }
//     return uf.parent[x]
// }

// func (uf *unionFind) union(x, y int) bool {
//     fx, fy := uf.find(x), uf.find(y)
//     if fx == fy {
//         return false
//     }
//     if uf.rank[fx] < uf.rank[fy] {
//         fx, fy = fy, fx
//     }
//     uf.rank[fx] += uf.rank[fy] //权重大的一方要继续加权重
//     uf.parent[fy] = fx
//     return true
// }

// func dist(p, q []int) int {
//     return abs(p[0]-q[0]) + abs(p[1]-q[1])
// }

// func minCostConnectPoints(points [][]int) (ans int) {
//     n := len(points)
//     type edge struct{ v, w, dis int }
//     edges := []edge{}
//     for i, p := range points {
//         for j := i + 1; j < n; j++ {
//             edges = append(edges, edge{i, j, dist(p, points[j])})
//         }
//     }

//     sort.Slice(edges, func(i, j int) bool { return edges[i].dis < edges[j].dis })

//     uf := newUnionFind(n)
//     left := n - 1
//     for _, e := range edges {
//         if uf.union(e.v, e.w) {
//             ans += e.dis
//             left--
//             if left == 0 {
//                 break
//             }
//         }
//     }
//     return
// }

// func abs(x int) int {
//     if x < 0 {
//         return -x
//     }
//     return x
// }

// func findLonely(nums []int) []int {
// 	if len(nums) == 0{
// 		return nil
// 	}
// 	resm := make(map[int]int)
// 	for i := 0; i < len(nums); i++{
// 		resm[nums[i]]++
// 	}
// 	res := make([]int, 0)
// 	for i, v := range resm{
// 		if v != 1{
// 			continue
// 		}
// 		_, ok1 := resm[i-1]
// 		_,ok2 := resm[i+1]
// 		if !ok1 && !ok2{
// 			res = append(res, i)
// 		}
// 	}
// 	return res
// }
// func rearrangeArray(nums []int) []int {
// 	if len(nums) == 0{
// 		return nil
// 	}
// 	f_nums := make([]int, 0)
// 	k_nums := make([]int,0)
// 	for i := 0; i < len(nums); i++{
// 		if nums[i] < 0{
// 			f_nums = append(f_nums, nums[i])
// 		}else{
// 			k_nums = append(k_nums, nums[i])
// 		}
// 	}
// 	res := make([]int, len(nums))
// 	j := 0
// 	for i := 0; i < len(nums)/2; i+=2{
// 		res[i] = f_nums[j]
// 		res[i+1] = k_nums[j]
// 		j++
// 	}
// 	return res
// }
// func countElements(nums []int) int {
// 	if len(nums) < 3{
// 		return 0
// 	}
// 	sort.Ints(nums)
// 	start,end := 0,0
// 	l,r := 0,1
// 	for r < len(nums){
// 		if nums[r] > nums[l]{
// 			start = r
// 			break
// 		}
// 		r++
// 	}
// 	l,r := len(nums) - 2,len(nums) - 1
// 	for l >= 0{
// 		if nums[l] < nums[r]{
// 			end = l
// 			break
// 		}
// 		l--
// 	}
// 	if end < start{
// 		return 0
// 	}
// 	return end - start + 1
// }
// func isPalindrome( x int ) bool {
//     // write code here
//     cnt := 0
//     if x < 0{
//         return false
//     }else if x / 10 == 0{
//         return true
//     }
//     num := x
//     for num != 0{
//         cnt++
//         num = num / 10
//     }

// 	// fmt.Println(cnt,x % 10,(x / int(math.Pow(10,float64(cnt - 1))) % 10))
//     if x % 10 != (x / int(math.Pow(10,float64(cnt - 1)))) % 10{
//         return false
//     }
//     fmt.Println(cnt)
//     for i := 1; i < cnt/2; i++{
//         n1 := (x / int(math.Pow(10,float64(i)))) % 10
//         n2 := (x / int(math.Pow(10,float64(cnt - i - 1)))) % 10
// 		fmt.Println(n1,n2)
//         if n1 != n2 {
//             return false
//         }
//     }
//     return true
// }
// type node struct {
// 	key int
// 	val int
// 	freq int
// 	prev, next     *node
// }

// type LFUCache struct {
// 	cap         int
// 	keyToNode   map[int]*node
// 	freqToNodes map[int]*doubleList
// 	minFreq     int
// }

// type doubleList struct {
// 	head, tail *node
// }

// func Constructor(cap int) LFUCache {
// 	return LFUCache{
// 		cap:         cap,
// 		keyToNode:   map[int]*node{},
// 		freqToNodes: map[int]*doubleList{}, //出现次数相同下的节点链表段
// 		minFreq:     0,
// 	}
// }

// func (_this *LFUCache) Get(key int) int {
// 	if node, ok := _this.keyToNode[key]; ok {
// 		//增加评率
// 		_this.increaseFreq(node)
// 		return node.val
// 	}
// 	return -1
// }

// func (_this *LFUCache) Put(key, val int) {
// 	/**
// 	步骤：
// 	1.判断容量是否合法
// 	2.判断key是否存在，是则更新val，并增加频率

// 	3.key不存在，新增key，需要判断容量是否还有
// 	3.1 否：删除最小使用频率的key
// 	3.2 是: 正常插入

// 	4.新增操作minFreq=1
// 	*/
// 	if _this.cap <= 0 {
// 		return
// 	}

// 	if node, ok := _this.keyToNode[key]; ok {
// 		node.val = val
// 		//增加评率
// 		_this.increaseFreq(node)
// 		return
// 	}

// 	if len(_this.keyToNode) >= _this.cap {
// 		//删除最小频率的key
// 		_this.deleteMinFreq()
// 	}

// 	//新增key操作
// 	value := &node{
// 		key:  key,
// 		val:  val,
// 		freq: 1,
// 	}
// 	_this.keyToNode[key] = value

// 	if _this.freqToNodes[value.freq] == nil {
// 		_this.freqToNodes[value.freq] = doubleListConstructor()
// 	}
// 	_this.freqToNodes[value.freq].add(value)

// 	_this.minFreq = 1
// }

// /**
// 增加node频率
// */
// func (_this *LFUCache) increaseFreq(node *node) {
// 	/**
// 	DL:doubleList,双向链表
// 	步骤：
// 	1.先从以前DL中移除node
// 	2.判断以前freq对应DL是否为空,是则minFreq++
// 	3.node.freq++并加入到新的DL中，加入新的DL是从队头加入，因此如果频次相同，则先删除队尾的，也就是距离当下时间最长的
// 	*/
// 	beforeFreq := node.freq
// 	oldDL := _this.freqToNodes[beforeFreq]
// 	oldDL.remove(node)

// 	if oldDL.isEmpty() && beforeFreq == _this.minFreq { //表示频率最低的节点的++
// 		_this.minFreq++
// 	}

// 	node.freq++
// 	if _this.freqToNodes[node.freq] == nil {
// 		_this.freqToNodes[node.freq] = doubleListConstructor()
// 	}
// 	_this.freqToNodes[node.freq].add(node)
// }

// /**
// 删除最小频率node
// */
// func (_this *LFUCache) deleteMinFreq() {
// 	/**
// 	步骤：
// 	1.DL中需要删除
// 	2.keyToNode需要删除
// 	*/
// 	dl := _this.freqToNodes[_this.minFreq]
// 	last := dl.last() //尾部，如果最低次数相同，则删除最久没有被访问的

// 	dl.remove(last)
// 	delete(_this.keyToNode, last.key)
// }

// /**
// 双向列表可以实现O(1)删除操作
//  */
// type doubleList struct {
// 	head, tail *node
// }

// func doubleListConstructor() *doubleList {
// 	head, tail := &node{}, &node{}
// 	head.next, tail.prev = tail, head

// 	return &doubleList{
// 		head: head,
// 		tail: tail,
// 	}
// }

// func (_this *doubleList) add(node *node) {
// 	prev, next := _this.head, _this.head.next
// 	prev.next, node.prev = node, prev
// 	next.prev, node.next = node, next
// }

// func (_this *doubleList) remove(node *node) {
// 	prev, next := node.prev, node.next
// 	prev.next, next.prev = next, prev
// 	node.prev, node.next = nil, nil
// }

// func (_this *doubleList) first() *node {
// 	return _this.head.next
// }

// func (_this *doubleList) last() *node {
// 	return _this.tail.prev
// }

// func (_this *doubleList) isEmpty() bool {
// 	return _this.head.next == _this.tail
// }

// func findMedianinTwoSortedAray( arr1 []int ,  arr2 []int ) int {
//     // write code here
// 	if len(arr1)  == 0{
// 		return 0
// 	}
// 	start1, end1 := 0, len(arr1) - 1
// 	start2, end2 := 0, len(arr2) - 1
// 	mid1, mid2 := 0, 0
// 	if len(arr1) % 2 == 0{
// 		mid1, mid2 = len(arr1) / 2 - 1, len(arr1) / 2 -1
// 	}else{
// 		mid1, mid2 = len(arr1) / 2, len(arr1) / 2
// 	}
// 	offset := 0
// 	for start1 < end1{
// 		mid1 = (start1 + end1) / 2
// 		mid2 = (start2 + end2) / 2
// 		offset = ((end1 - start1 + 1) & 1) ^ 1

// 		if arr1[mid1] > arr2[mid2]{
// 			end1 = mid1
// 			start2 = mid2 + offset
// 		}else if arr1[mid1] < arr2[mid2]{
// 			start1 = mid1 + offset
// 			end2 = mid2
// 		}else{
// 			return arr1[mid1]
// 		}
// 	}
// 	return min(arr1[start1],arr2[start2])
// }

// func reverseBetween( head *ListNode ,  m int ,  n int ) *ListNode {
//     // write code here
//     if head == nil || m == n{
//         return head
//     }
//     dump := &ListNode{}
//     dump.Next  = head
//     head = dump

//     for m - 1 != 0{
//         head = head.Next
//         m--
//     }

//     nhead := head
//     revhead := head.Next
//     head.Next = nil
//     head = revhead

//     for n - m  !=  0{
//         head = head.Next
//         n--
//     }

//     ntail := head.Next
//     head.Next = nil

//     pre := reverse(nhead)

//     nhead.Next = pre
//     revhead.Next = ntail

//     return dump.Next
// }

// func reverse(root *ListNode) *ListNode{
//     if root == nil{
//         return nil
//     }
//     var pre *ListNode
//     for root == nil{
//         temp := root.Next
//         root.Next = pre
//         pre = root
//         root = temp
//     }
// 	strconv.For
//     return pre
// }
// func solve( M int ,  N int ) string {
//     // write code here
//     res := ""
//     for M >= N{

//         str := strconv.FormatInt(int64(M % N),10)
//         if str >= "10"{
//             str +='A' - byte(10)
//         }
//         M /= N
//         res = str + res
//     }
// 	num := strconv.FormatInt(int64(M),10)
// 	if num >= "10"{
// 		num += "A" - "10"
// 	}
//     res = num + res

//     return res
// }
// type kstr struct{
// 	str string
// 	cnt int
// }
// func topKstrings( strings []string ,  k int ) [][]string {
//     // write code here
//     if len(strings) == 0{
// 		return nil
// 	}
// 	strm := make(map[string]int)
// 	for _,v := range strings{
// 		strm[v]++
// 	}
// 	kstrsli := make([]kstr,0)
// 	for i,v := range strm{
// 		k := kstr{
// 			str: i,
// 			cnt: v,
// 		}
// 		kstrsli = append(kstrsli,k)
// 	}
// 	sort.Slice(kstrsli,func(i,j int) bool{
// 		return kstrsli[i].cnt < kstrsli[j].cnt || (kstrsli[i].cnt ==  kstrsli[j].cnt && kstrsli[i].str > kstrsli[j].str)
// 	})
// 	result := make([][]string,k)
// 	for i := 0; i < k; i++{
// 		num := strconv.FormatInt(int64(kstrsli[len(kstrsli)-1-i].cnt),10)
// 		result[i] = []string{kstrsli[len(kstrsli)-1-i].str,num}
// 	}
// 	return result
// }
// func solve( s string ) int {
//     // write code here
// 	return value([]byte(s),0)[0]
// }

// func value(s []byte, index int) []int{
// 	dep := make([]int,0) //存储表达式
// 	pre := 0
// 	bra := make([]int,0)

// 	for i := 0; i < len(s) && s[i] != ')'; i++{
// 		if s[i] >= '0' && s[i] <= 9{
// 			pre = pre * 10 + s[i] - '0'
// 		}else if s[i] != '('{
// 			addNum(dep,pre)
// 			dep = append(dep,int(s[i]))
// 			pre = 0
// 		}else{
// 			bra = value(s,i+1)
// 			pre = bra[0]
// 			i = bra[1] + 1
// 		}
// 	}
// 	addNum(dep,pre)
// 	return []int{getNum(dep),i}
// }

// func addNum(s *[]int,0)
// func solve(s string) int {
//     // 把每次运算的结果放到该栈中
//     stack := make([]int, 0)

//     // 字符串转换为字符切片
//     data := /*[]byte(s)*/ s

//     // 表示字符串中每一个数字
//     number := 0
//     // 初识状态操作符
//     operation := byte('+')

//     // 处理字符串
//     for i := 0; i < len(data); i++ {
//         // 当前字符
//         c := data[i]

//         // 0~9 字符是数字
//         if c >= '0' && c <= '9' {
//             number = 10*number + int(c-'0')
//             //continue 不能写continue，因为如果是最后一个字符的话，需要特殊处理
//         }

//         // '('
//         // 遇到左括号特殊处理，还会进入到递归中
//         if c == '(' {
//             // 遇到的第一个左括号
//             count := 1
//             // 进入递归需要处理的开始于截止
//             start, end := i+1, i+1

//             // 每一次遇到括号，就是一层递归
//             // 每一次递归都是去掉最外层的一对括号，直到没有括号
//             // count == 0 就是最有一个右括号
//             for count != 0 {
//                 // 遇到左括号 ++
//                 if data[end] == '(' {
//                     count++
//                 }
//                 //遇到右括号 --
//                 if data[end] == ')' {
//                     count--
//                 }

//                 end++
//             }

//             // 已经处理好的字符位置
//             i = end - 1

//             // 进入递归，并顺便传入需要处理的字符串
//             // start, end-1 为需要处理的字符串的开始于截止位置
//             number = solve(s[start : end])
//         }

//         // c < '0' || c > '9' 表示 '+' / '-' / '*'
//         // i == len(data)-1 表示已经是最后一个字符了，此时需要进行最后的一次运算
//         if c == '+' || c == '-' || c == '*' || i == len(data)-1 {
//             switch operation {
//             case '+':
//                 stack = append(stack, number)
//             case '-':
//                 stack = append(stack, -number)
//             case '*':
//                 stack[len(stack)-1] = stack[len(stack)-1] * number
//             }

//             // 重置数字
//             number = 0

//             // 当前的操作符号，前面已经对括号进行了处理，这里不会有括号
//             //  i == len(data)-1 时，operation 无意义了
//             operation = c
//         }
//     }

//     // 累加栈中每一个数字
//     result := 0
//     for len(stack) != 0 {
//         result += stack[len(stack)-1]
//         stack = stack[:len(stack)-1]
//     }

//     return result
// }
// func f(inputs []int) []int {
// 	if len(inputs) == 0 {
// 		return nil
// 	}

// 	d := make([]int, len(inputs))
// 	ends := make([]int, len(inputs))
// 	maxvalue, index := 1, 0
// 	right := 0
// 	d[0], ends[0] = 1, inputs[0]

// 	for i := 1; i < len(inputs); i++ {
// 		l, r := 0, right
// 		for l <= r {
// 			m := (l + r) / 2
// 			if ends[m] < inputs[i] {											//这种序列长度
// 				l = m + 1
// 			} else {
// 				r = m - 1
// 			}
// 		}
// 		right = max(right, l)
// 		ends[l] = inputs[i]
// 		d[i] = l + 1
// 		if maxvalue < l+1 {
// 			maxvalue = l + 1
// 			index = i
// 		} else if maxvalue == l+1 && inputs[index] > inputs[i] { //这里是因为要求字典序，因此最大值
// 			index = i
// 		}
// 	}

// 	res := make([]int, maxvalue)
// 	for i, j := index, 0; i >= 0 && maxvalue != 0; i-- {
// 		if d[i] == maxvalue {
// 			if i-1 >= 0  && inputs[i-1] < inputs[i] && d[i] == d[i-1]{ //最小字典序
// 				continue
// 			}
// 			maxvalue--
// 			res[len(res)-j-1] = inputs[i]
// 			j++
// 		}
// 	}
// 	return res
// }

// func matrixPower(m [][]int, p int) [][]int { //p是需要乘的阶乘
// 	res := make([][]int, len(m))
// 	for i := 0; i < len(res); i++ { //转为单位矩阵
// 		res[i] = make([]int, len(m[0]))
// 		res[i][i] = 1
// 	}
// 	tmp := m
// 	for ; p != 0; p = p >> 1 {
// 		if (p & 1) != 0 { //P对应位为1的进行累乘
// 			res = muliMatrix(res, tmp)
// 		}
// 		tmp = muliMatrix(tmp, tmp) //tmp自乘
// 	}
// 	return res
// }
// func muliMatrix(m1 [][]int, m2 [][]int) [][]int {
// 	res := make([][]int, len(m1))
// 	for i := 0; i < len(res); i++ {
// 		res[i] = make([]int, len(m1[0]))
// 	}
// //下面这个就是个矩阵乘法
// 	for i := 0; i < len(m1); i++ {
// 		for j := 0; j < len(m2[0]); j++ {
// 			for k := 0; k < len(m2); k++ {
// 				res[i][j] = (res[i][j] + m1[i][k]*m2[k][j]) % (1e9 + 7)
// 			}
// 		}
// 	}
// 	return res
// }
// func solve( s string ,  t string ) string {
//     // write code here

//     m := len(s)
//     n := len(t)

//     // let m < n
//     if m > n {
//         m,n = n,m
//         s,t = t,s
//     }
//     //s是两者之间长度小的那个，长度为m

//     ret := make([]byte, n + 1)

//     carry := 0
//     for i:=0; i< n; i++ {
//         longN := int(t[n-i-1] - '0')
//         shortN := 0
//         if m-i-1 >= 0 {
//             shortN = int(s[m-i-1] - '0')
//         }

//         result := longN + shortN + carry
//         carry = result / 10
//         result = result % 10
//         ret[n-i] = byte(result + '0')
//     }

//     if carry == 1 {
//         ret[0] = '1'
//         return string(ret)
//     }

//     return string(ret[1:])
// }
// func maxLength( arr []int ) int {
//     // write code here
//     if len(arr) == 0{
//         return 0
//     }
//     indexm := make(map[int]int)
//     l := 0
//     res := 1
//     r := 0
//     for r = 0; r < len(arr); r++{
//         if i,ok := indexm[arr[r]];ok{
// 			if i < l{
// 				indexm[arr[r]] = r
// 				continue
// 			}
//             res = max(res,r-l)
// 			fmt.Println(l,r,i,res)
//             l = i+1

//         }
//          indexm[arr[r]] = r

//     }
//     res = max(res,r-l)
// 	fmt.Println(l,r,res)
//     return res
// }

// type LRUCache struct {
//     size int
//     capacity int
//     cache map[int]*DLinkedNode
//     head, tail *DLinkedNode
// }

// type DLinkedNode struct {
//     key, value int
//     prev, next *DLinkedNode
// }

// func initDLinkedNode(key, value int) *DLinkedNode {
//     return &DLinkedNode{
//         key: key,
//         value: value,
//     }
// }

// func Constructor(capacity int) LRUCache {
//     l := LRUCache{
//         cache: map[int]*DLinkedNode{},
//         head: initDLinkedNode(0, 0),
//         tail: initDLinkedNode(0, 0),
//         capacity: capacity,
//     }
//     l.head.next = l.tail
//     l.tail.prev = l.head
//     return l
// }

// func (this *LRUCache) Get(key int) int {
//     if _, ok := this.cache[key]; !ok {
//         return -1
//     }
//     node := this.cache[key]
//     this.moveToHead(node)
//     return node.value
// }

// func (this *LRUCache) Put(key int, value int)  {
//     if _, ok := this.cache[key]; !ok {
//         node := initDLinkedNode(key, value)
//         this.cache[key] = node
//         this.addToHead(node)
//         this.size++
//         if this.size > this.capacity {
//             removed := this.removeTail()
//             delete(this.cache, removed.key)
//             this.size--
//         }
//     } else {
//         node := this.cache[key]
//         node.value = value
//         this.moveToHead(node)
//     }
// }

// func (this *LRUCache) addToHead(node *DLinkedNode) {
//     node.prev = this.head
//     node.next = this.head.next
//     this.head.next.prev = node
//     this.head.next = node
// }

// func (this *LRUCache) removeNode(node *DLinkedNode) {
//     node.prev.next = node.next
//     node.next.prev = node.prev
// }

// func (this *LRUCache) moveToHead(node *DLinkedNode) {
//     this.removeNode(node)
//     this.addToHead(node)
// }

// func (this *LRUCache) removeTail() *DLinkedNode {
//     node := this.tail.prev
//     this.removeNode(node)
//     return node
// }

// func minmumNumberOfHost( n int ,  startEnd [][]int ) int {
//     // write code here
//     if n == 0 || n == 1{
//         return n
//     }
//     sort.Slice(startEnd,func(x,y int)bool{
//         return startEnd[x][0] < startEnd[y][0] || (startEnd[x][0] == startEnd[y][0] && startEnd[x][1] < startEnd[y][1])
//     })
//     stack := make([]int,0)
//     stack = append(stack,math.MinInt32)
//     for _,v := range startEnd{
//         for i:=0;i<len(stack);i++{
//             if stack[i] <= v[0]{
//                 stack = append(stack[:i],stack[i+1:]...)
//                 break
//             }
//         }
//         stack = append(stack,v[1])
//     }
//     return len(stack)
// }func minmumNumberOfHost( n int ,  startEnd [][]int ) int {
//     // write code here
//     if n == 0 || n == 1{
//         return n
//     }
//     sort.Slice(startEnd,func(x,y int)bool{
//         return startEnd[x][0] < startEnd[y][0] || (startEnd[x][0] == startEnd[y][0] && startEnd[x][1] < startEnd[y][1])
//     })
//     stack := make([]int,0)
//     stack = append(stack,math.MinInt32)
//     for _,v := range startEnd{
//         if stack[i] <= v[0]{
//             stack = append(stack[:i],stack[i+1:]...)

// 		}
// 		l,r := 0,len(stack)
// 		for l < r{
// 			mid := l + (r - l )/2
// 			if stack[mid] < v[1]{
// 				l = mid+1
// 			}else{
// 				r = mid-1
// 			}
// 		}
// 		if stack[l] < v[1]{
// 			stack = append(stack[:l+1],append([]int{v[1],stack[l+2:]}...)...)
// 		}else{
// 			stack = append(stack[:l],append([]int{v[1],stack[l+1:]}...)...)
// 		}
//     }
//     return len(stack)
// }
// func minmumNumberOfHost(n int, startEnd [][]int) int {
// 	// write code here
// 	if n == 0 {
// 		return 0
// 	}
// 	dp := make([][]int, n)
// 	for i := 0; i < n; i++ {
// 		dp[i] = make([]int, n)
// 		dp[i][i] = 1
// 	}
// 	sort.Slice(startEnd, func(x, y int) bool {
// 		return startEnd[x][0] < startEnd[y][0] || (startEnd[x][0] == startEnd[y][0] && startEnd[x][1] < startEnd[y][1])
// 	})

// 	for i := n - 1; i >= 0; i-- {
// 		for j := i + 1; j < n; j++ {
// 			dp[i][j] = max(dp[i][j-1], dp[i+1][j])
// 			if startEnd[i][1] > startEnd[j][0] {
// 				dp[i][j] = max(dp[i+1][j], dp[i][j-1]) + 1
// 			}
// 		}
// 		fmt.Println(dp)
// 	}
// 	return dp[0][n-1]
// }

// func trieU(operators [][]string) []string {
// 	// write code here
// 	prefix := NewPriexTrie()
// 	res := make([]string, 0)
// 	for _, v := range operators {
// 		k := v[0]
// 		if k == "1" {
// 			prefix.insert(v[1])
// 		} else if k == "2" {
// 			prefix.delete(v[1])
// 		} else if k == "3" {
// 			res = append(res, prefix.search(v[1]))
// 		} else {
// 			num := strconv.FormatInt(int64(prefix.prefixNumber(v[1])), 10)
// 			res = append(res, num)
// 		}
// 	}
// 	return res
// }

// type PriexTrie struct {
// 	index [26]*PriexTrie
// 	//     cnt        int  //表示已当前结尾的单词添加的次数
// 	flag       bool //bool表示有以此结尾的单词
// 	priexcount int  //该前缀包哈你的单词的数量
// }

// func NewPriexTrie() *PriexTrie {
// 	return &PriexTrie{}
// }

// func (this *PriexTrie) insert(str string) {
// 	head := this
// 	for i := 0; i < len(str); i++ {
// 		if head.index[str[i]-'a'] != nil {
// 			head = head.index[str[i]-'a']
// 		} else {
// 			node := &PriexTrie{}
// 			head.index[str[i]-'a'] = node
// 			head = head.index[str[i]-'a']
// 		}
// 		head.priexcount++
// 	}
// 	head.flag = true
// 	//     head.cnt++
// }

// func (this *PriexTrie) delete(str string) {
// 	head := this
// 	for i := 0; i < len(str); i++ {
// 		if head.index[str[i]-'a'] != nil {
// 			head = head.index[str[i]-'a']
// 		} else {
// 			return
// 		}
// 		head.priexcount--
// 	}
// 	head.flag = false
// }

// func (this *PriexTrie) search(str string) string {
// 	head := this
// 	for i := 0; i < len(str); i++ {
// 		if head.index[str[i]-'a'] != nil {
// 			head = head.index[str[i]-'a']
// 		} else {
// 			return "NO"
// 		}
// 	}
// 	if head.flag {
// 		return "YES"
// 	}
// 	return "NO"
// }

// func (this *PriexTrie) prefixNumber(str string) int {
// 	head := this
// 	for i := 0; i < len(str); i++ {
// 		if head.index[str[i]-'a'] != nil {
// 			head = head.index[str[i]-'a']
// 		} else {
// 			return 0
// 		}
// 	}
// 	return head.priexcount
// }

// func isMatch(s string, p string) bool {
//     m, n := len(s), len(p)
//     matches := func(i, j int) bool {
//         if i == 0 {
//             return false
//         }
//         if p[j-1] == '.' {
//             return true
//         }
//         return s[i-1] == p[j-1]
//     }

//     f := make([][]bool, m + 1)
//     for i := 0; i < len(f); i++ {
//         f[i] = make([]bool, n + 1)
//     }
// 	strconv.FormatInt(int)
//     f[0][0] = true
//     for i := 0; i <= m; i++ {
//         for j := 1; j <= n; j++ {
//             if p[j-1] == '*' {
//                 f[i][j] = f[i][j] || f[i][j-2]
//                 if matches(i, j - 1) {
//                     f[i][j] = f[i][j] || f[i-1][j]
//                 }
//             } else if matches(i, j) {
//                 f[i][j] = f[i][j] || f[i-1][j-1]
//             }
//         }
//     }
//     return f[m][n]
// }

// func decodeString(s string) string {
// 	// write code here
// 	stack := make([]string, 0)
// 	for i := 0; i < len(s); i++ {
// 		if s[i] != ']' {
// 			stack = append(stack, string(s[i]))
// 			continue
// 		}
// 		s := ""
// 		for len(stack) != 0 && stack[len(stack)-1] != "[" {
// 			s = string(stack[len(stack)-1]) + s
// 			stack = stack[:len(stack)-1]
// 		}
// 		stack = stack[:len(stack)-1]
// 		// fmt.Println(s)
// 		cnt, _ := strconv.ParseInt(string(stack[len(stack)-1]), 10, 32)
// 		// fmt.Println(cnt)
// 		stack = stack[:len(stack)-1]
// 		str := ""
// 		for cnt != 0 {
// 			str += s
// 			cnt--
// 		}
// 		// fmt.Println(str, string(stack))
// 		stack = append(stack, str)
// 	}
// 	return stack[0]
// }

// type variesnum struct {
// 	yes_go int
// 	no_go  int
// }
// func mostPoints(questions [][]int) int64 {
// 	if len(questions) == 0 {
// 		return 0
// 	}
// 	yesdp := make([][]int,len(questions))
// 	nodp := make([][]int,len(questions))
// 	for i:=0;i<len(yesdp);i++{
// 		yesdp[i] = make([]int,len(questions))
// 		nodp[i] = make([]int,len(questions))
// 	}
// 	for i:=0;i<len(dp)
// }

// type variesnum struct {
// 	yes_go int
// 	no_go  int
// }

// func mostPoints(questions [][]int) int64 {
// 	if len(questions) == 0 {
// 		return 0
// 	}
//     yesdp :=make([]*variesnum,len(questions))
// 	var dfs func(qs [][]int,index int) variesnum
// 	dfs = func(qs [][]int,index int) variesnum {
// 		if index >= len(qs) {
// 			return variesnum{0, 0}
// 		}else if index == len(qs) - 1{
// 			return variesnum{qs[index][0],0}
// 		}
// 		yes := qs[index][0]
// 		no := 0

// 		if index+qs[index][1]+1 < len(qs) {
//             if yesdp[index+qs[index][1]+1] != nil{
//                 yes += max(yesdp[index+qs[index][1]+1].yes_go,yesdp[index+qs[index][1]+1].no_go)
//             }else{
//                 y1 := dfs(qs,index+qs[index][1]+1)
// 			    yes += max(y1.yes_go, y1.no_go)
//             }
// 		}
//         if index+1 < len(questions) && yesdp[index+1] != nil{
//             no += max(yesdp[index+1].yes_go,yesdp[index+1].no_go)
//         }else{
//             n1 := dfs(qs,index+1)
//             no += max(n1.yes_go, n1.no_go)
//         }
//         yesdp[index] = &variesnum{yes,no}
// 		return variesnum{yes, no}
// 	}
// 	value := dfs(questions,0)
// 	return int64(max(value.no_go, value.yes_go))
// }

// func tree(root *Employ) int {
// 	if root == nil {
// 		return 0
// 	}
// 	var dfs func(root *Employ) *variesnum
// 	dfs = func(root *Employ) *variesnum {
// 		yes_go := root.happy
// 		no_go := 0

// 		for _, v := range root.subordinates {
// 			value := dfs(v)
// 			yes_go += value.no_go                   //包含当前节点则不能包含子节点
// 			no_go += max(value.no_go, value.yes_go) //不包含当前节点，则可以取包含子节点或者不包含子节点的最大值
// 		}
// 		return &variesnum{yes_go, no_go}
// 	}
// 	res := dfs(root)
// 	return max(res.no_go, res.yes_go)
// }

// func minMoves(target int, maxDoubles int) int {
// 	if maxDoubles == 0 {
// 		return target - 1
// 	}
// 	if target == 1 {
// 		return 0
// 	}
// 	cnt := 0
// 	for maxDoubles != 0 {
// 		if target == 1 {
// 			return cnt
// 		}
// 		if target%2 != 0 {
// 			target--
// 		} else {
// 			target = target / 2
// 			maxDoubles--
// 		}
// 		cnt++
// 	}
// 	if target != 1 {
// 		cnt += target - 1
// 	}
// 	return cnt
// }

// func minMoves(target int, maxDoubles int) int {
// 	if maxDoubles == 0 {
// 		return target - 1
// 	}
// 	dp := make([][]int, maxDoubles+1)
// 	for i := 0; i < len(dp); i++ {
// 		dp[i] = make([]int, target+1)
// 	}
// 	for i := 1; i < len(dp[0]); i++ {
// 		dp[0][i] = i - 1
// 	}
// 	// fmt.Println(dp)
// 	for i := 1; i < len(dp); i++ {
// 		for j := 2; j < len(dp[0]); j++ {
// 			dp[i][j] = dp[i][j-1] + 1
// 			if j%2 == 0 {
// 				dp[i][j] = min(dp[i][j], dp[i-1][j/2]+1)
// 			}
// 			// fmt.Println(dp)
// 		}
// 	}
// 	return dp[maxDoubles][target]
// }

// func divideString(s string, k int, fill byte) []string {
// 	if s == "" {
// 		return nil
// 	}
// 	res := make([]string, 0)
// 	str := ""
// 	for i := 0; i < len(s); i++ {
// 		str += string(s[i])
// 		if len(str) == k {
// 			res = append(res, str)
// 			str = ""
// 		}
// 	}
// 	if len(str) != 0 {
// 		for len(str) != k {
// 			str += string(fill)
// 		}
// 		res = append(res, str)
// 	}
// 	return res
// }

// func quickSort(nums []int) []int {
// 	if len(nums) == 0 {
// 		return nil
// 	}
// 	var quickdfssort func(nums []int)
// 	quickdfssort = func(nums []int) {
// 		if len(nums) <= 1 {
// 			return
// 		}
// 		num := nums[len(nums)-1]
// 		l, r := 0, 0
// 		for r < len(nums)-1 {
// 			if nums[r] <= num {
// 				nums[l], nums[r] = nums[r], nums[l]
// 				r++
// 				l++
// 			} else {
// 				r++
// 			}
// 		}
// 		nums[l], nums[len(nums)-1] = nums[len(nums)-1], nums[l]
// 		quickdfssort(nums[:l])
// 		quickdfssort(nums[l+1:])
// 	}
// 	quickdfssort(nums)
// 	return nums
// }

// func twofind(nums []int,target int) int{
// 	if len(nums) == 0{
// 		return 0
// 	}
// 	l,r := 0,len(nums)-1
// 	for l + 1 < r{
// 		mid := l + (r - l) / 2
// 		if nums[mid] == target{
// 			return mid
// 		}else if nums[mid] < target{
// 			l = mid
// 		}else{
// 			r = mid
// 		}
// 	}
// 	if nums[l] == target{
// 		return l
// 	}
// 	return r
// }
// func minmumNumberOfHost( n int ,  startEnd [][]int ) int {
//     // write code here
//     if n == 0 || n == 1{
//         return n
//     }
//     sort.Slice(startEnd,func(x,y int)bool{
//         return startEnd[x][0] < startEnd[y][0] || (startEnd[x][0] == startEnd[y][0] && startEnd[x][1] < startEnd[y][1])
//     })
//     stack := make([]int,0)
//     stack = append(stack,math.MinInt32)
//     for _,v := range startEnd{
//         for i:=0;i<len(stack);i++{
//             if stack[i] <= v[0]{
//                 stack = append(stack[:i],stack[i+1:]...)
//                 break
//             }
//         }
//         stack = append(stack,v[1])
//     }
//     return len(stack)
// }func minmumNumberOfHost( n int ,  startEnd [][]int ) int {
//     // write code here
//     if n == 0 || n == 1{
//         return n
//     }
//     sort.Slice(startEnd,func(x,y int)bool{
//         return startEnd[x][0] < startEnd[y][0] || (startEnd[x][0] == startEnd[y][0] && startEnd[x][1] < startEnd[y][1])
//     })
//     stack := make([]int,0)
//     stack = append(stack,math.MinInt32)
//     for _,v := range startEnd{
//         if stack[i] <= v[0]{
//             stack = append(stack[:i],stack[i+1:]...)

// 		}
// 		l,r := 0,len(stack)
// 		for l < r{
// 			mid := l + (r - l )/2
// 			if stack[mid] < v[1]{
// 				l = mid+1
// 			}else{
// 				r = mid-1
// 			}
// 		}
// 		if stack[l] < v[1]{
// 			stack = append(stack[:l+1],append([]int{v[1],stack[l+2:]}...)...)
// 		}else{
// 			stack = append(stack[:l],append([]int{v[1],stack[l+1:]}...)...)
// 		}
//     }
//     return len(stack)
// }
// func minmumNumberOfHost(n int, startEnd [][]int) int {
// 	// write code here
// 	if n == 0 {
// 		return 0
// 	}
// 	dp := make([][]int, n)
// 	for i := 0; i < n; i++ {
// 		dp[i] = make([]int, n)
// 		dp[i][i] = 1
// 	}
// 	sort.Slice(startEnd, func(x, y int) bool {
// 		return startEnd[x][0] < startEnd[y][0] || (startEnd[x][0] == startEnd[y][0] && startEnd[x][1] < startEnd[y][1])
// 	})

// 	for i := n - 1; i >= 0; i-- {
// 		for j := i + 1; j < n; j++ {
// 			dp[i][j] = max(dp[i][j-1], dp[i+1][j])
// 			if startEnd[i][1] > startEnd[j][0] {
// 				dp[i][j] = max(dp[i+1][j], dp[i][j-1]) + 1
// 			}
// 		}
// 		fmt.Println(dp)
// 	}
// 	return dp[0][n-1]
// }

// func trieU(operators [][]string) []string {
// 	// write code here
// 	prefix := NewPriexTrie()
// 	res := make([]string, 0)
// 	for _, v := range operators {
// 		k := v[0]
// 		if k == "1" {
// 			prefix.insert(v[1])
// 		} else if k == "2" {
// 			prefix.delete(v[1])
// 		} else if k == "3" {
// 			res = append(res, prefix.search(v[1]))
// 		} else {
// 			num := strconv.FormatInt(int64(prefix.prefixNumber(v[1])), 10)
// 			res = append(res, num)
// 		}
// 	}
// 	return res
// }

// type PriexTrie struct {
// 	index [26]*PriexTrie
// 	//     cnt        int  //表示已当前结尾的单词添加的次数
// 	flag       bool //bool表示有以此结尾的单词
// 	priexcount int  //该前缀包哈你的单词的数量
// }

// func NewPriexTrie() *PriexTrie {
// 	return &PriexTrie{}
// }

// func (this *PriexTrie) insert(str string) {
// 	head := this
// 	for i := 0; i < len(str); i++ {
// 		if head.index[str[i]-'a'] != nil {
// 			head = head.index[str[i]-'a']
// 		} else {
// 			node := &PriexTrie{}
// 			head.index[str[i]-'a'] = node
// 			head = head.index[str[i]-'a']
// 		}
// 		head.priexcount++
// 	}
// 	head.flag = true
// 	//     head.cnt++
// }

// func (this *PriexTrie) delete(str string) {
// 	head := this
// 	for i := 0; i < len(str); i++ {
// 		if head.index[str[i]-'a'] != nil {
// 			head = head.index[str[i]-'a']
// 		} else {
// 			return
// 		}
// 		head.priexcount--
// 	}
// 	head.flag = false
// }

// func (this *PriexTrie) search(str string) string {
// 	head := this
// 	for i := 0; i < len(str); i++ {
// 		if head.index[str[i]-'a'] != nil {
// 			head = head.index[str[i]-'a']
// 		} else {
// 			return "NO"
// 		}
// 	}
// 	if head.flag {
// 		return "YES"
// 	}
// 	return "NO"
// }

// func (this *PriexTrie) prefixNumber(str string) int {
// 	head := this
// 	for i := 0; i < len(str); i++ {
// 		if head.index[str[i]-'a'] != nil {
// 			head = head.index[str[i]-'a']
// 		} else {
// 			return 0
// 		}
// 	}
// 	return head.priexcount
// }

// func isMatch(s string, p string) bool {
//     m, n := len(s), len(p)
//     matches := func(i, j int) bool {
//         if i == 0 {
//             return false
//         }
//         if p[j-1] == '.' {
//             return true
//         }
//         return s[i-1] == p[j-1]
//     }

//     f := make([][]bool, m + 1)
//     for i := 0; i < len(f); i++ {
//         f[i] = make([]bool, n + 1)
//     }
// 	strconv.FormatInt(int)
//     f[0][0] = true
//     for i := 0; i <= m; i++ {
//         for j := 1; j <= n; j++ {
//             if p[j-1] == '*' {
//                 f[i][j] = f[i][j] || f[i][j-2]
//                 if matches(i, j - 1) {
//                     f[i][j] = f[i][j] || f[i-1][j]
//                 }
//             } else if matches(i, j) {
//                 f[i][j] = f[i][j] || f[i-1][j-1]
//             }
//         }
//     }
//     return f[m][n]
// }

// func decodeString(s string) string {
// 	// write code here
// 	stack := make([]string, 0)
// 	for i := 0; i < len(s); i++ {
// 		if s[i] != ']' {
// 			stack = append(stack, string(s[i]))
// 			continue
// 		}
// 		s := ""
// 		for len(stack) != 0 && stack[len(stack)-1] != "[" {
// 			s = string(stack[len(stack)-1]) + s
// 			stack = stack[:len(stack)-1]
// 		}
// 		stack = stack[:len(stack)-1]
// 		// fmt.Println(s)
// 		cnt, _ := strconv.ParseInt(string(stack[len(stack)-1]), 10, 32)
// 		// fmt.Println(cnt)
// 		stack = stack[:len(stack)-1]
// 		str := ""
// 		for cnt != 0 {
// 			str += s
// 			cnt--
// 		}
// 		// fmt.Println(str, string(stack))
// 		stack = append(stack, str)
// 	}
// 	return stack[0]
// }

// func uniquePaths(m, n int) int {
//     dp := make([][]int, m)
//     for i := range dp {
//         dp[i] = make([]int, n)
//         dp[i][0] = 1
//     }
//     for j := 0; j < n; j++ {
//         dp[0][j] = 1
//     }
//     for i := 1; i < m; i++ {
//         for j := 1; j < n; j++ {
//             dp[i][j] = dp[i-1][j] + dp[i][j-1]
//         }
//     }
//     return dp[m-1][n-1]
// }

// func uniquePaths(m int, n int) int {
// 	f := make([][]int, m)
// 	for i := 0; i < m; i++ {
// 		f[i] = make([]int, n)
// 	}
// 	res := 0
// 	var dfs func(f *[][]int, x, y int)
// 	dfs = func(f *[][]int, x, y int) {
// 		if x >= m || y >= n || x < 0 || y < 0 {
// 			return
// 		}
// 		if x == m-1 && y == n-1 {
// 			res++
// 			return
// 		}
// 		if x+1 < m && (*f)[x+1][y] != 1 {
// 			(*f)[x+1][y] = 1
// 			dfs(f, x+1, y)
// 			(*f)[x+1][y] = 0
// 		}
// 		if x-1 >= 0 && (*f)[x-1][y] != 1 {
// 			(*f)[x-1][y] = 1
// 			dfs(f, x-1, y)
// 			(*f)[x-1][y] = 0
// 		}
// 		if y+1 < n && (*f)[x][y+1] != 1 {
// 			(*f)[x][y+1] = 1
// 			dfs(f, x, y+1)
// 			(*f)[x][y+1] = 0
// 		}

// 		if y-1 >= 0 && (*f)[x][y-1] != 1 {
// 			(*f)[x][y-1] = 1
// 			dfs(f, x, y-1)
// 			(*f)[x][y-1] = 0
// 		}
// 	}
// 	dfs(&f, 0, 0)
// 	return res
// }

// func maxPathSum(root *TreeNode) int {
// 	if root == nil {
// 		return 0
// 	}
// 	maxvalue := math.MaxInt32
// 	var dfs func(root *TreeNode) int
// 	dfs = func(root *TreeNode) int {
// 		if root == nil {
// 			return math.MaxInt32
// 		}
// 		l := dfs(root.Left)
// 		r := dfs(root.Right)
// 		m := max(l, r)
// 		maxvalue = max(maxvalue, max(m, root.Val))
// 		maxvalue = max(maxvalue, max(m+root.Val, l+r+root.Val))
// 		return max(m+root.Val, root.Val)
// 	}
// 	dfs(root)
// 	return maxvalue
// }

// func search(nums []int, target int) int {
// 	if len(nums) == 0 {
// 		return -1
// 	}

// 	start := 0
// 	end := len(nums) - 1

// 	for start+1 < end {
// 		mid := start + (end-start)/2
// 		if nums[mid] == target {
// 			return mid
// 		}
// 		if nums[mid] > nums[end] {
// 			if nums[start] <= target && nums[mid] >= target {
// 				end = mid
// 			} else {
// 				start = mid
// 			}
// 		} else if nums[mid] < nums[end] {
// 			if nums[mid] <= target && nums[end] >= target {
// 				start = mid
// 			} else {
// 				end = mid
// 			}
// 		}
// 	}

// 	if nums[start] == target {
// 		return start
// 	}
// 	if nums[end] == target {
// 		return end
// 	}
// 	return -1
// }

// func sortList(head *ListNode) *ListNode {
// 	if head == nil || head.Next == nil {
// 		return head
// 	}
// 	mid := FindMid(head)
// 	l1 := sortList(head)
// 	l2 := sortList(mid)
// 	return mergeList(l1, l2)
// }

// func mergeList(list1 *ListNode, list2 *ListNode) *ListNode {
// 	if list1 == nil {
// 		return list2
// 	} else if list2 == nil {
// 		return list1
// 	}
// 	dump := &ListNode{}
// 	head := dump
// 	for list1 != nil && list2 != nil {
// 		if list1.Val > list2.Val {
// 			head.Next = list2
// 			list2 = list2.Next
// 		} else {
// 			head.Next = list1
// 			list1 = list1.Next
// 		}
// 	}
// 	if list1 != nil {
// 		head.Next = list1
// 	}
// 	if list2 != nil {
// 		head.Next = list2
// 	}
// 	return dump.Next
// }

// func FindMid(head *ListNode) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	dump := &ListNode{}
// 	dump.Next = head
// 	slow, quick := dump, dump
// 	for quick != nil && quick.Next != nil {
// 		slow = slow.Next
// 		quick = quick.Next.Next
// 	}
// 	temp := slow.Next
// 	slow.Next = nil
// 	return temp
// }

// func reverse(x int) int {
// 	flag := false //false表示正数
// 	if x < 0 {
// 		flag = true
// 		x = -1 * x
// 	}
// 	maxvalue := -1 * math.MinInt32
// 	str := strconv.FormatInt(int64(x), 10)
// 	sbyte := []byte(str)
// 	for i := 0; i < len(sbyte)/2; i++ {
// 		sbyte[i], sbyte[len(sbyte)-1-i] = sbyte[len(sbyte)-1-i], sbyte[i]
// 	}
// 	num, err := strconv.ParseInt(string(sbyte), 10, 32)
// 	if err != nil {
// 		return 0
// 	}
// 	if flag {
// 		if num > int64(maxvalue) {
// 			return 0
// 		} else {
// 			return -1 * int(num)
// 		}
// 	}
// 	if num > int64(maxvalue)-1 {
// 		return 0
// 	}
// 	return int(num)
// }

// func mergeKLists(lists []*ListNode) *ListNode {
// 	if len(lists) == 0 {
// 		return nil
// 	} else if len(lists) == 1 {
// 		return lists[0]
// 	}
// 	left := mergeKLists(lists[:len(lists)/2])
// 	right := mergeKLists(lists[len(lists)/2:])
// 	list := mergetList(left, right)
// 	return list
// }

// func mergetList(list1 *ListNode, list2 *ListNode) *ListNode {
// 	if list1 == nil {
// 		return list2
// 	} else if list2 == nil {
// 		return list1
// 	}
// 	dump := &ListNode{}
// 	head := dump

// 	for list1 != nil && list2 != nil {
// 		if list1.Val > list2.Val {
// 			head.Next = list2
// 			list2 = list2.Next
// 		} else {
// 			head.Next = list1
// 			list1 = list1.Next
// 		}
// 		head = head.Next
// 	}
// 	if list1 != nil {
// 		head.Next = list1
// 	}
// 	if list2 != nil {
// 		head.Next = list2
// 	}
// 	return dump.Next
// }

// type single struct{}

// var Single *single
// var lock sync.Mutex

// func NewSingle() *single {
// 	if Single == nil {
// 		lock.Lock()
// 		if Single == nil {
// 			Single = &single{}
// 		}
// 	}
// 	return Single
// }

// func merge(nums1 []int, m int, nums2 []int, n int) {
// 	if n == 0 {
// 		return
// 	}

// 	l, r := 0, m
// 	for l < m {
// 		nums1[r] = nums1[l]
// 		l++
// 		r++
// 	}
// 	l, r = m, 0
// 	start := 0
// 	for l < m+n && r < n {
// 		if nums1[l] < nums2[r] {
// 			nums1[start] = nums1[l]
// 			l++
// 		} else {
// 			nums1[start] = nums2[r]
// 			r++
// 		}
// 	}
// 	if r >= n {
// 		return
// 	}
// 	for r < n {
// 		nums1[start] = nums2[r]
// 		r++
// 	}
// }

// func productExceptSelf(nums []int) []int {

// }
// func multiply(num1 string, num2 string) string {
// 	if num1 == "0" || num2 == "0" {
// 		return "0"
// 	}
// 	result := make([]int, len(num1)+len(num2))
// 	for i, n1 := range num1 {
// 		for j, n2 := range num2 {
// 			result[i+j+1] += int(n1-'0') * int(n2-'0')
// 		}
// 	}
// 	for i := len(result) - 1; i > 0; i-- {
// 		if result[i] >= 10 {
// 			result[i-1] += result[i] / 10
// 			result[i] %= 10
// 		}
// 	}
// 	res := ""
// 	nonzero := false
// 	for _, r := range result {
// 		if nonzero || r != 0 {
// 			nonzero = true
// 			res += string(rune(r) + '0')
// 		}
// 	}
// 	return res
// }

// func multiply(num1 string, num2 string) string {
// 	if num1 == "0" || num2 == "0" {
// 		return "0"
// 	}
// 	res := ""
// 	str1 := ""
// 	str2 := ""
// 	if len(num1) > len(num2) {
// 		str1 = num1
// 		str2 = num2
// 	} else {
// 		str1 = num2
// 		str2 = num1
// 	}
// 	// fmt.Println(str1, str2)
// 	index := 1
// 	for i := len(str2) - 1; i >= 0; i-- {
// 		sum := ComputeMulti(str1, string(str2[i]))
// 		sum = sum + SumZero(index)

// 		res = SumTwo(res, string(sum))
// 		// fmt.Println(sum, index, res)
// 		index *= 10
// 	}
// 	return res
// }
// func SumZero(index int) string {
// 	res := ""
// 	for index != 1 {
// 		res += "0"
// 		index = index / 10
// 	}
// 	return res
// }
// func SumTwo(str1, str2 string) string {
// 	res := ""
// 	i, j := len(str1)-1, len(str2)-1
// 	flag := 0
// 	for i >= 0 || j >= 0 {
// 		n, m := 0, 0
// 		if i >= 0 {
// 			n, _ = strconv.Atoi(string(str1[i]))
// 			i--
// 		}
// 		if j >= 0 {
// 			m, _ = strconv.Atoi(string(str2[j]))
// 			j--
// 		}

// 		value := strconv.FormatInt(int64(n+m+flag)%10, 10)

// 		res = value + res
// 		// fmt.Println(n, m, value, res)
// 		if n+m+flag >= 10 {
// 			flag = 1
// 		} else {
// 			flag = 0
// 		}

// 	}
// 	if flag != 0 {
// 		res = "1" + res
// 	}
// 	return res
// }
// func ComputeMulti(str1 string, num string) string {
// 	res := ""
// 	flag := 0
// 	m, _ := strconv.ParseInt(num, 10, 32)

// 	for i := len(str1) - 1; i >= 0; i-- {
// 		n, _ := strconv.ParseInt(string(str1[i]), 10, 32)

// 		value := strconv.FormatInt(int64(((n*m + int64(flag)) % 10)), 10)
// 		res = value + res
// 		if int(n)*int(m)+flag >= 10 {
// 			flag = (int(n)*int(m) + flag) / 10
// 		} else {
// 			flag = 0
// 		}
// 		// fmt.Println("1", n, m, value, res, flag)
// 	}
// 	if flag != 0 {
// 		value := strconv.FormatInt(int64(flag), 10)
// 		res = value + res
// 	}

// 	return res
// }

// func maxArea(height []int) int {
// 	if len(height) == 0 {
// 		return 0
// 	}
// 	i := 0
// 	res := 0
// 	for i < len(height) {
// 		k := i
// 		temp := i + 1
// 		flag := false
// 		for temp < len(height) {
// 			for temp < len(height) && height[temp] < height[i] {
// 				temp++
// 			}
// 			if temp < len(height) {
// 				res = max(res, (temp-i)*height[i])
// 				if !flag {
// 					k = temp
// 				}
// 				temp++
// 			}
// 		}
// 		if k == i {
// 			i++
// 		} else {
// 			i = k
// 		}
// 	}
// 	i = len(height) - 1
// 	for i >= 0 {
// 		k := i
// 		temp := i - 1
// 		flag := false
// 		for temp >= 0 {
// 			for temp >= 0 && height[temp] < height[i] {
// 				temp--
// 			}
// 			if temp >= 0 {
// 				res = max(res, (i-temp)*height[i])
// 				if !flag {
// 					k = temp
// 				}
// 				temp--
// 			}
// 		}
// 		if k == i {
// 			i++
// 		} else {
// 			i = k
// 		}
// 	}
// 	return res
// }

// func isValid(s string) bool {
// 	if len(s) == 0 {
// 		return true
// 	}
// 	stack := make([]byte, 0)
// 	for i := 0; i < len(s); i++ {
// 		if s[i] == '(' || s[i] == '{' || s[i] == '[' {
// 			stack = append(stack, s[i])
// 		} else {
// 			if len(stack) != 0 {
// 				if s[i] == ')' && stack[len(stack)-1] == '(' {
// 					stack = stack[:len(stack)-1]
// 				} else if s[i] == ']' && stack[len(stack)-1] == '[' {
// 					stack = stack[:len(stack)-1]
// 				} else if s[i] == '}' && stack[len(stack)-1] == '{' {
// 					stack = stack[:len(stack)-1]
// 				} else {
// 					return false
// 				}
// 			} else {
// 				return false
// 			}
// 		}
// 	}
// 	if len(stack) == 0 {
// 		return true
// 	}
// 	return false
// }

// func threeSumClosest(nums []int, target int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}

// 	res := 0
// 	temp := math.MaxInt32
// 	sort.Ints(nums)
// 	fmt.Println(nums)
// 	var closeTree func(num int, l, r int)
// 	closeTree = func(num int, l, r int) {
// 		for l < r {
// 			sum := num + nums[l] + nums[r]
// 			fmt.Println(sum, target, res)
// 			if sum-target == 0 {
// 				temp = 0
// 				res = sum
// 				return
// 			} else if sum-target < 0 {
// 				if temp > target-sum {
// 					temp = target - sum
// 					res = sum
// 				}
// 				l++
// 			} else {
// 				if temp > sum-target {
// 					temp = sum - target
// 					res = sum
// 				}
// 				r--
// 			}
// 		}
// 	}
// 	for i := 0; i <= len(nums)-3; i++ {
// 		if i == 0 || nums[i] != nums[i-1] {
// 			closeTree(nums[i], i+1, len(nums)-1)
// 		}
// 	}
// 	return res
// }

// func threeSum(nums []int) [][]int {
// 	if len(nums) < 3 {
// 		return nil
// 	}
// 	result := make([][]int, 0)

// 	sort.Ints(nums)
// 	var threeSum func(sum int, l int, r int)
// 	threeSum = func(sum int, l int, r int) {
// 		for l < r {
// 			res := sum + nums[l] + nums[r]
// 			if res == 0 {
// 				result = append(result, []int{sum, nums[l], nums[r]})
// 				l++
// 				for l < r && nums[l] == nums[l-1] {
// 					l++
// 				}
// 			} else if res < 0 {
// 				l++
// 			} else {
// 				r--
// 			}
// 		}
// 	}

// 	for i := 0; i <= len(nums)-3; i++ {
// 		if i == 0 || nums[i] != nums[i-1] {
// 			threeSum(nums[i], i+1, len(nums)-1)
// 		}
// 	}
// 	return result
// }

// type treeNode struct {
// 	next  map[byte]*treeNode
// 	count int
// }

// func longestCommonPrefix(strs []string) string {
// 	if len(strs) == 0 {
// 		return ""
// 	}
// 	str := strs[0]
// 	var newtree func(str string) *treeNode
// 	newtree = func(str string) *treeNode {
// 		if len(str) == 0 {
// 			return nil
// 		}
// 		root := &treeNode{
// 			next: make(map[byte]*treeNode),
// 		}
// 		head := root
// 		for i := 0; i < len(str); i++ {
// 			if _, ok := head.next[str[i]]; !ok {
// 				head.next[str[i]] = &treeNode{
// 					next: make(map[byte]*treeNode),
// 				}
// 			}
// 			head.next[str[i]].count++
// 			head = head.next[str[i]]
// 		}
// 		return root
// 	}
// 	var Sumtree func(root *treeNode, str string)
// 	Sumtree = func(root *treeNode, str string) {
// 		if len(str) == 0 {
// 			return
// 		}
// 		for i := 0; i < len(str); i++ {
// 			if _, ok := root.next[str[i]]; !ok {
// 				break
// 			}
// 			root.next[str[i]].count++
// 			root = root.next[str[i]]
// 		}
// 	}
// 	root := newtree(str)
// 	for i := 1; i < len(strs); i++ {
// 		head := root
// 		Sumtree(head, strs[i])
// 	}
// 	res := ""
// 	for root != nil {
// 		for i, v := range root.next {
// 			if v.count == len(strs) {
// 				res += string(i)
// 				root = root.next[i]
// 				break
// 			} else {
// 				goto loop
// 			}
// 		}
// 	}
// loop:
// 	return res
// }

// func myAtoi(s string) int {
// 	if len(s) == 0 {
// 		return 0
// 	}
// 	// strs := strings.Split(s, " ")
// 	sbyte := []byte(s)
// 	flag := false //false表示为正数，否则是负数
// 	for len(sbyte) != 0 && sbyte[0] == ' ' {
// 		sbyte = sbyte[1:]
// 	}
// 	if len(sbyte) != 0 && sbyte[0] == '-' {
// 		flag = true
// 		sbyte = sbyte[1:]
// 	}
// 	for len(sbyte) != 0 && sbyte[0] == '0' {
// 		sbyte = sbyte[1:]
// 	}

// 	sum := 0
// 	maxnum := math.MinInt32 * -1
// 	for i := 0; i < len(sbyte); i++ {
// 		if sbyte[i] >= '0' && sbyte[i] <= '9' {
// 			num, _ := strconv.ParseInt(string(sbyte[i]), 10, 32)
// 			sum = sum*10 + int(num)
// 			if sum >= maxnum {
// 				break
// 			}
// 		} else {
// 			break
// 		}
// 		// fmt.Println(sum, string(sbyte[0]))
// 	}
// 	fmt.Println(flag, sum)
// 	if flag {
// 		if sum > maxnum {
// 			return -1 * maxnum
// 		} else {
// 			return -1 * sum
// 		}
// 	} else {
// 		if sum > maxnum-1 {
// 			return math.MaxInt32
// 		} else {
// 			return sum
// 		}
// 	}
// }

// func longestPalindrome(s string) string {
// 	if len(s) == 0 {
// 		return ""
// 	}
// 	str := string(s[0])
// 	value := 0
// 	dp := make([][]bool, len(s))
// 	for i := 0; i < len(dp); i++ {
// 		dp[i] = make([]bool, len(s))
// 	}
// 	for i := len(s) - 1; i >= 0; i-- {
// 		for j := i; j < len(s); j++ {
// 			if s[i] == s[j] && (j-i <= 1 || dp[i+1][j-1]) {
// 				dp[i][j] = true
// 				if j-i > value {
// 					str = s[i : j+1]
// 					value = j - i
// 				}
// 			}
// 		}
// 	}
// 	return str
// }

// func findMedianSortedArrays(nums1 []int, nums2 []int) float64 {
// 	if len(nums1) == 0 && len(nums2) == 0 {
// 		return 0
// 	}
// 	nums1 = append(nums1, nums2...)
// 	sort.Ints(nums1)
// 	if len(nums1)%2 != 0 {
// 		return float64(nums1[len(nums1)/2])
// 	} else {
// 		return float64(nums1[len(nums1)/2-1]+nums1[len(nums1)/2]) / 2.0
// 	}
// }

// func change(target int, nums []int) int {
// 	if len(nums) == 0 || target == 0 {
// 		return 0
// 	}
// 	dp := make([][]int, len(nums)+1)
// 	for i := 0; i < len(dp); i++ {
// 		dp[i] = make([]int, target+1)
// 	}
// 	for i := 1; i < len(dp); i++ {
// 		dp[i][0] = 1
// 		for j := 1; j < len(dp[0]); j++ {
// 			if j-nums[i] >= 0 {
// 				dp[i][j] = dp[i][j-nums[i]] + dp[i-1][j]
// 			} else {
// 				dp[i][j] = dp[i-1][j]
// 			}
// 		}
// 	}
// 	return dp[len(nums)][target]
// }

// func main() {
// 	c := make(chan int, 10)
// 	// exit := make(chan int, 10)
// 	var w sync.WaitGroup
// 	for i := 0; i < 100; i++ {
// 		w.Add(1)
// 		go func(i int) {
// 			c <- i
// 			fmt.Println(i)
// 			<-c
// 			w.Done()
// 		}(i)
// 	}
// 	w.Wait()
// }

// func possibleToStamp(a [][]int, h, w int) (ans bool) {
// 	n, m := len(a), len(a[0])
// 	var sum1 [][]int
// 	initSum1 := func(a [][]int) {
// 		n, m := len(a), len(a[0])
// 		sum1 = make([][]int, n+1)
// 		sum1[0] = make([]int, m+1)
// 		for i, row := range a {
// 			sum1[i+1] = make([]int, m+1)
// 			for j, v := range row {
// 				sum1[i+1][j+1] = sum1[i+1][j] + sum1[i][j+1] - sum1[i][j] + v
// 			}
// 		}
// 	}

// 	querySum1 := func(r1, c1, r2, c2 int) int {
// 		r2++
// 		c2++
// 		return sum1[r2][c2] - sum1[r2][c1] - sum1[r1][c2] + sum1[r1][c1]
// 	}

// 	initSum1(a)
// 	d := make([][]int, n+1)
// 	for i := range d {
// 		d[i] = make([]int, m+1)
// 	}

// 	for i, r := range a {
// 		for j, v := range r {
// 			if v == 1 {
// 				continue
// 			}
// 			if i+h<=n && j+w<=m {
// 				x,y := i+h-1,j+w-1
// 				if querySum1(i,j,x,y) > 0 {
// 					continue
// 				}
// 				d[i][j]++
// 				d[i][y+1]--
// 				d[x+1][j]--
// 				d[x+1][y+1]++
// 			}
// 		}
// 	}

// 	var sum2 [][]int
// 	initSum2 := func(a [][]int) {
// 		n, m := len(a), len(a[0])
// 		sum2 = make([][]int, n+1)
// 		sum2[0] = make([]int, m+1)
// 		for i, row := range a {
// 			sum2[i+1] = make([]int, m+1)
// 			for j, v := range row {
// 				sum2[i+1][j+1] = sum2[i+1][j] + sum2[i][j+1] - sum2[i][j] + v
// 			}
// 		}
// 	}
// 	initSum2(d)
// 	for i, r := range a {
// 		for j, v := range r {
// 			_, _ = i, j
// 			if v == 1 {
// 				continue
// 			}
// 			if sum2[i+1][j+1] == 0 {
// 				return false
// 			}
// 		}
// 	}
// 	return true
// }

// func minSwaps(nums []int) int {
// 	tot1 := 0
// 	for _, num := range nums {
// 		tot1 += num
// 	}
// 	cnt1, maxCnt1 := 0, 0
// 	nums = append(nums, nums...) // 断环成链
// 	for i, num := range nums {
// 		cnt1 += num
// 		if i >= tot1 { // 滑窗
// 			cnt1 -= nums[i-tot1]
// 			if cnt1 > maxCnt1 {
// 				maxCnt1 = cnt1
// 			}
// 		}
// 	}
// 	return tot1 - maxCnt1
// }

// type Consistent struct {
// 	//排序的hash虚拟结点
// 	hashSortedNodes []uint32
// 	//虚拟结点对应的结点信息
// 	circle map[uint32]string
// 	//已绑定的结点
// 	nodes map[string]bool
// 	//map读写锁
// 	sync.RWMutex
// 	//虚拟结点数
// 	virtualNodeCount int
// }

// func (c *Consistent) hashKey(key string) uint32 {
// 	return crc32.ChecksumIEEE([]byte(key))
// }

// func (c *Consistent) Add(node string, virtualNodeCount int) error {
// 	if node == "" {
// 		return nil
// 	}
// 	c.Lock()
// 	defer c.Unlock()

// 	if c.circle == nil {
// 		c.circle = map[uint32]string{}
// 	}
// 	if c.nodes == nil {
// 		c.nodes = map[string]bool{}
// 	}

// 	if _, ok := c.nodes[node]; ok {
// 		return errors.New("node already existed")
// 	}
// 	c.nodes[node] = true
// 	//增加虚拟结点
// 	for i := 0; i < virtualNodeCount; i++ {
// 		virtualKey := c.hashKey(node + strconv.Itoa(i))
// 		c.circle[virtualKey] = node
// 		c.hashSortedNodes = append(c.hashSortedNodes, virtualKey)
// 	}

// 	//虚拟结点排序
// 	sort.Slice(c.hashSortedNodes, func(i, j int) bool {
// 		return c.hashSortedNodes[i] < c.hashSortedNodes[j]
// 	})

// 	return nil
// }

// func (c *Consistent) GetNode(key string) string {
// 	c.RLock()
// 	defer c.RUnlock()

// 	hash := c.hashKey(key)
// 	i := c.getPosition(hash)

// 	return c.circle[c.hashSortedNodes[i]]
// }

// func (c *Consistent) getPosition(hash uint32) int {
// 	i := sort.Search(len(c.hashSortedNodes), func(i int) bool { return c.hashSortedNodes[i] >= hash })

// 	if i < len(c.hashSortedNodes) {
// 		if i == len(c.hashSortedNodes)-1 {
// 			return 0
// 		} else {
// 			return i
// 		}
// 	} else {
// 		return len(c.hashSortedNodes) - 1
// 	}
// }

// var lock = &sync.Mutex{}
// var lock sync.Mutex

// type single struct{}

// var singleInstance *single

// func getInstance() *single {
// 	if singleInstance == nil {
// 		lock.Lock()
// 		defer lock.Unlock()
// 		if singleInstance == nil {
// 			fmt.Println("Creating single instance now.")
// 			singleInstance = &single{}
// 		} else {
// 			fmt.Println("Single instance already created.")
// 		}
// 	} else {
// 		fmt.Println("Single instance already created.")
// 	}

// 	return singleInstance
// }

// func minSwaps(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	n := len(nums)
// 	numsone := 0
// 	for i := 0; i < len(nums); i++ {
// 		if nums[i] == 1 {
// 			numsone++
// 		}
// 	}
// 	if numsone == n {
// 		return 0
// 	}
// 	left := 0
// 	right := n - 1
// 	leftnum, rightnum := 0, 0
// 	tmpl, tmpr := 0, 0
// 	i, j := 0, n-1
// 	for i+1 < j {
// 		if nums[i] == 0 {
// 			if leftnum < tmpl {
// 				left = i - tmpl
// 				leftnum = tmpl
// 			}
// 			tmpl = 0
// 		} else {
// 			tmpl++
// 		}

// 		if nums[j] == 0 {
// 			if rightnum < tmpr {
// 				right = j + tmpr
// 				rightnum = tmpr
// 			}
// 			tmpr = 0
// 		} else {
// 			tmpr++
// 		}
// 		i++
// 		j--
// 	}
// 	sum := 0
// 	if i == j {
// 		sum = tmpl + tmpr - 1
// 	}else if {

// 	}
// 	k := newIndex(right, n)
// 	fmt.Println(left, right, k)
// 	if k == left {
// 		return numsone - leftnum + rightnum
// 	}
// 	chazhi := left + n - right - 1
// 	if chazhi == numsone-leftnum+rightnum {
// 		return numsone - leftnum + rightnum
// 	}
// 	return numsone - max(leftnum, rightnum)
// }

// func minSwaps(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}

// 	maxvalue := 0

// 	l := 0
// 	for l < len(nums) {
// 		if nums[l] == 0 {
// 			break
// 		}
// 		l++
// 	}
// 	if l == len(nums) {
// 		return 0
// 	}
// 	index := newIndex(l, len(nums))
// 	tmp := 0

// 	for index != l {

// 		if nums[index] == 0 {
// 			maxvalue = max(maxvalue, tmp)
// 			tmp = 0
// 		} else {
// 			tmp++
// 		}
// 		// fmt.Println(index, nums[index], tmp)
// 		index = newIndex(index, len(nums))
// 	}
// 	maxvalue = max(maxvalue, tmp)
// 	// fmt.Println(maxvalue)

// 	len1 := 0
// 	for i := 0; i < len(nums); i++ {
// 		if nums[i] == 1 {
// 			len1++
// 		}
// 	}
// 	target1 := len1 - maxvalue
// 	flag
// 	for i:=0;i<len(nums)
// 	return len1 - maxvalue
// }

func newIndex(i int, l int) int {
	if i+1 == l {
		return 0
	}
	return i + 1
}

// func checkValid(matrix [][]int) bool {
// 	if len(matrix) == 0 {
// 		return true
// 	}

// 	for i := 0; i < len(matrix); i++ {
// 		indexm := make(map[int]int)
// 		for j := 0; j < len(matrix[0]); j++ {
// 			if matrix[i][j] < 1 || matrix[i][j] > len(matrix[0]) {
// 				return false
// 			}
// 			if _, ok := indexm[matrix[i][j]]; ok {
// 				return false
// 			} else {
// 				indexm[matrix[i][j]]++
// 			}
// 		}
// 		if len(indexm) != len(matrix) {
// 			return false
// 		}
// 	}
// 	for i := 0; i < len(matrix[0]); i++ {
// 		indexm := make(map[int]int)
// 		for j := 0; j < len(matrix); j++ {
// 			if matrix[i][j] < 1 || matrix[i][j] > len(matrix[0]) {
// 				return false
// 			}
// 			if _, ok := indexm[matrix[i][j]]; ok {
// 				return false
// 			} else {
// 				indexm[matrix[i][j]]++
// 			}
// 		}
// 		if len(indexm) != len(matrix) {
// 			return false
// 		}
// 	}
// 	return true
// }

// func Qpsquestion(){
// 	var cnt int
// 	//创建一个定时器
// 	//创建一个tcp监听
// 	//为每个tcp开启一个read
// 	//read的同时记录cnt++和对应的时间戳，然后判断如果cnt++>=阈值并且时间戳在60s内拒绝该请求，如果超过60s则清零重新开始计数

// }
// func main() {
// 	// strs := []string{"a", "b", "c", "d", "e", "f", "g"}
// 	nums := []int{1, 2, 3, 4, 5, 6, 7}
// 	ch1 := make(chan int, 0)
// 	ch2 := make(chan int, 0)
// 	exit := make(chan int, 1)
// 	index := 0
// 	go func() {
// 		for {
// 			k := <-ch2
// 			if k >= len(nums) {
// 				break
// 			}
// 			fmt.Println("1", nums[k])
// 			ch1 <- k + 1
// 		}
// 		exit <- 1
// 	}()

// 	go func() {
// 		k := index
// 		for index < len(nums) {
// 			ch2 <- k
// 			fmt.Println("2", nums[k])
// 			k = <-ch1
// 		}
// 		exit <- 1
// 	}()
// 	<-exit
// }

// func ps(s *string) {
// 	*s = "hoo"
// }

// type Node struct {
// 	value int
// 	next  *Node
// }

// type List struct {
// 	head, tail *Node
// }

// func main() {
// 	k := [][]int{{1, 0, 0, 0}, {1, 0, 0, 0}, {1, 0, 0, 0}, {1, 0, 0, 0}, {1, 0, 0, 0}}
// 	fmt.Println(possibleToStamp(k, 4, 3))
// }

// func possibleToStamp(grid [][]int, stampHeight int, stampWidth int) bool {

// 	rightgrid := make([][]int, len(grid))
// 	downtgrid := make([][]int, len(grid))
// 	target := make([][]int, len(grid))
// 	for i := 0; i < len(grid); i++ {
// 		rightgrid[i] = make([]int, len(grid[i]))
// 		downtgrid[i] = make([]int, len(grid[i]))
// 		target[i] = make([]int, len(grid[i]))
// 	}

// 	for i := 0; i < len(grid); i++ {
// 		if grid[i][len(grid[0])-1] != 1 {
// 			rightgrid[i][len(grid[0])-1] = 1
// 		}
// 		for j := len(grid[0]) - 2; j >= 0; j-- {
// 			if grid[i][j] != 1 {
// 				rightgrid[i][j] = rightgrid[i][j+1] + 1
// 			}
// 		}
// 	}
// 	for i := 0; i < len(grid[0]); i++ {
// 		if grid[len(grid)-1][i] != 1 {
// 			downtgrid[len(grid)-1][i] = 1
// 		}
// 		for j := len(grid) - 2; j >= 0; j-- {
// 			if grid[j][i] != 1 {
// 				downtgrid[j][i] = downtgrid[j+1][i] + 1
// 			}
// 		}
// 	}

// 	fmt.Println(rightgrid)
// 	fmt.Println(downtgrid)
// 	for i := 0; i < len(grid); i++ {
// 		for j := 0; j < len(grid[0]); j++ {
// 			if grid[i][j] == 1 {
// 				target[i][j] = 1
// 				continue
// 			}
// 			w := rightgrid[i][j]
// 			h := downtgrid[i][j]
// 			if w == 0 || h == 0 {
// 				continue
// 			}
// 			if j+stampWidth-1 >= len(grid[0]) || j+stampWidth-1 > w || stampHeight+i-1 >= len(grid) || stampHeight+i-1 > h {
// 				continue
// 			}
// 			flag1 := false
// 			flag2 := false
// 			for k := i; k <= stampHeight+i-1; k++ {
// 				if j+stampWidth-1 > w {
// 					flag1 = true
// 					break
// 				}
// 			}
// 			for k := j; k <= j+stampWidth-1; k++ {
// 				if stampHeight+i-1 > h {
// 					flag2 = true
// 					break
// 				}
// 			}
// 			if flag2 || flag1 {
// 				continue
// 			}

// 			for k := i; k <= stampHeight+i-1; k++ {
// 				for d := j; d <= j+stampWidth-1; d++ {
// 					target[k][d] = 1
// 				}
// 			}
// 		}
// 	}
// 	for i := 0; i < len(grid); i++ {
// 		for j := 0; j < len(grid[0]); j++ {
// 			if target[i][j] != 1 {
// 				return false
// 			}
// 		}
// 	}
// 	return true
// }

// func longestPalindrome(words []string) int {
// 	res := 0
// 	indexm := make(map[string]int)
// 	for i := 0; i < len(words); i++ {
// 		indexm[words[i]]++
// 	}
// 	cnt := false
// 	for i, v := range indexm {
// 		if Isreverse(i) {
// 			if v == 1 && !cnt {
// 				res += 2
// 				cnt = true
// 			} else if v%2 == 0 {
// 				res += 2 * v
// 			} else if v%2 != 0 {
// 				if !cnt {
// 					res += v * 2
// 					cnt = true

// 				} else {
// 					res += (v - 1) * 2
// 				}

// 			}
// 		} else {
// 			if n, ok := indexm[ReverseStr(i)]; ok {
// 				minvalue := min(n, v)
// 				res += minvalue * 4
// 				delete(indexm, ReverseStr(i))
// 			}
// 		}
// 	}
// 	return res
// }

// func ReverseStr(str string) string {
// 	bytestr := []byte(str)

// 	for i := 0; i < len(str)/2; i++ {
// 		bytestr[i], bytestr[len(str)-1-i] = bytestr[len(str)-1-i], bytestr[i]
// 	}
// 	return string(bytestr)
// }
// func Isreverse(str string) bool {
// 	for i := 0; i < len(str)/2; i++ {
// 		if str[i] != str[len(str)-1-i] {
// 			return false
// 		}
// 	}
// 	return true
// }

// func pairSum(head *ListNode) int {
// 	if head == nil {
// 		return 0
// 	}
// 	dump := &ListNode{}
// 	dump.Next = head
// 	slow := dump
// 	quick := dump
// 	for quick != nil && quick.Next != nil {
// 		slow = slow.Next
// 		quick = quick.Next.Next
// 	}
// 	start := slow.Next
// 	slow.Next = nil
// 	last := reverseList(start)
// 	res := 0
// 	start = dump.Next
// 	for start != nil && last != nil {
// 		if start.Val+last.Val > res {
// 			res = start.Val + last.Val
// 		}
// 		start = start.Next
// 		last = last.Next
// 	}
// 	return res
// }

// func reverseList(head *ListNode) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	var pre *ListNode
// 	for head != nil {
// 		temp := head.Next
// 		head.Next = pre
// 		pre = head
// 		head = temp
// 	}
// 	return pre
// }

// func capitalizeTitle(title string) string {
// 	strs := strings.Split(title, " ")
// 	res := ""

// 	for i := 0; i < len(strs); i++ {
// 		if len(strs[i]) <= 2 {
// 			str := strings.ToLower(strs[i])
// 			strs[i] = str
// 		} else {
// 			str := strings.ToLower(strs[i])
// 			str = strings.Title(str)

// 			strs[i] = str
// 		}
// 		res += strs[i] + " "
// 	}
// 	return res
// }

// type Node struct {
// 	value int
// 	next  *Node
// }

// func listquestion(head *Node) {
// 	if head == nil {
// 		return
// 	}
// 	dump := &Node{}
// 	dump.next = head
// 	slow, quick := dump, dump
// 	for quick != nil && quick.next != nil {
// 		slow = slow.next
// 		quick = quick.next.next
// 	}
// 	last := slow.next
// 	slow.next = nil
// 	start := dump.next
// 	cut := dump
// 	for start != nil || last != nil {
// 		if start != nil {
// 			cut.next = start
// 			start = start.next
// 			cut = cut.next
// 		}
// 		if last != nil {
// 			cut.next = last
// 			last = last.next
// 			cut = cut.next
// 		}
// 	}

// 	for dump.next != nil {
// 		out.WriteString(fmt.Sprintf("%d ", dump.next.value))
// 		dump = dump.next
// 	}
// }

// type Node struct {
// 	Val  int
// 	Next *Node
// }
// func insert(aNode *Node, x int) *Node {
// 	if aNode == nil {
// 		aNode := &Node{Val: x}
// 		aNode.Next = aNode
// 		return aNode
// 	}

// 	curr := aNode
// 	for !(curr.Val <= x && x <= curr.Next.Val || curr.Next.Val < curr.Val && (curr.Val <= x || x <= curr Next.Val) || curr.Next == aNode) { // 相等时，上述条件进入死循环，所以判断一下
// 		curr = curr.Next
// 	}
//     curr.Next = &Node{Val: x, Next: curr.Next}

// 	return aNode
// }

// func listquestion(head *node) {
// 	if head == nil {
// 		return
// 	}

// 	var findminnode func(head *node) *node
// 	findminnode = func(head *node) *node {
// 		small := head
// 		var smallPre *v
// 		pre := head
// 		cut := head.next
// 		for cut != nil {
// 			if cut.val < small.val {
// 				small = cut
// 				smallPre = pre
// 			}
// 			pre = cut
// 			cut = cut.Next
// 		}
// 		return smallPre
// 	}
// 	small := head
// 	var smallPre *node
// 	cut := head
// 	var tail *node
// 	for head != nil {
// 		pre := findminnode(small)
// 		if pre != nil {
// 			small = pre.next
// 			smallPre = pre
// 		}

// 		if tail == nil {
// 			head = small
// 		} else {
// 			tail.next = small
// 		}
// 		tail = small
// 	}

// 	for head != nil {
// 		out.WriteString(fmt.Sprintf("%d ", head.val))
// 		head = head.next
// 	}
// 	out.Flush()
// }

// func listquestion(root *TreeNode) {
// 	if root == nil {
// 		return
// 	}
// 	nums := make([]int, 0)
// 	var dfs func(root *TreeNode)
// 	dfs = func(root *TreeNode) {
// 		if root == nil {
// 			return
// 		}
// 		dfs(root.Left)
// 		nums = append(nums, root.Val)
// 		dfs(root.Right)
// 	}
// 	dfs(root)
// 	dump := &ListNode{}
// 	start := dump

// 	for i := 0; i < len(nums); i++ {
// 		node := &ListNode{
// 			Val: nums[i],
// 		}
// 		start.Next = node
// 		node.Pre = start
// 		start = start.Next
// 	}
// 	for dump.Next != nil {
// 		out.WriteString(fmt.Sprintf("%d ", dump.Next.Val))
// 	}
// }

// func listquestion(head *ListNode, target int) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	dump := &ListNode{}
// 	dump.Next = head

// 	pre := dump
// 	for head != nil {
// 		if head.Val == target {
// 			pre.Next = head.Next
// 			head = head.Next
// 		} else {
// 			pre = head
// 			head = head.Next
// 		}
// 	}
// 	return dump.Next
// }

// func listquestion(head *ListNode) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	dump := &ListNode{}
// 	dump.Next = head
// 	indexm := make(map[int]struct{})
// 	pre := dump
// 	for head != nil {
// 		if _, ok := indexm[head.Val]; ok {
// 			pre.Next = head.Next
// 			head = head.Next
// 		} else {
// 			indexm[head.Val] = struct{}{}
// 			pre = head
// 			head = head.Next
// 		}
// 	}
// 	return dump.Next
// }

// func reverseKGroup(head *ListNode, k int) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	dump := &ListNode{}
// 	dump.Next = head
// 	start := dump
// 	for start != nil && k > 0 {
// 		start = start.Next
// 	}
// 	if start == nil && k > 0 {
// 		return head
// 	}
// 	newstart := start.Next
// 	start.Next = nil
// 	tail := dump.Next
// 	rev := reverseList(dump.Next)
// 	tail.Next = reverseKGroup(newstart, k)
// 	return rev
// }

// func reverseList(head *ListNode) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	var pre *ListNode
// 	for head != nil {
// 		temp := head.Next
// 		head.Next = pre
// 		pre = head
// 		head = temp
// 	}
// 	return pre
// }

// class Solution {
//     public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
//         List<TreeNode> listP = new ArrayList<>();
//         List<TreeNode> listQ = new ArrayList<>();
//         findNode(root, p, listP);
//         findNode(root, q, listQ);
//         for (int i = Math.min(listP.size(), listQ.size()) - 1; i >= 0; --i)
//             if (listP.get(i) == listQ.get(i)) return listP.get(i);
//         return root;
//     }
//     private boolean findNode(TreeNode root, TreeNode val, List<TreeNode> list) {
//         if (root == null) return false;
//         list.add(root);
//         if (root == val || findNode(root.left, val, list) || findNode(root.right, val, list)) return true;
//         list.remove(list.size() - 1);
//         return false;
//     }
// }

// func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
// 	if p == nil || q == nil {
// 		return nil
// 	}
// 	pm := make([]*TreeNode, 0)
// 	qm := make([]*TreeNode, 0)
// 	var findNode func(root *TreeNode, node *TreeNode, m *[]*TreeNode) bool
// 	findNode = func(root *TreeNode, node *TreeNode, m *[]*TreeNode) bool {
// 		if root == nil {
// 			return false
// 		}
// 		(*m) = append((*m), root)
// 		if root == node || findNode(root.Left, node, m) || findNode(root.Right, node, m) {
// 			return true
// 		}
// 		(*m) = (*m)[:len(*m)-1]
// 		return false
// 	}
// 	findNode(root, p, &pm)
// 	findNode(root, q, &qm)
// 	for i := min(len(pm), len(qm)) - 1; i >= 0; i-- {
// 		if pm[i] == qm[i] {
// 			return pm[i]
// 		}
// 	}
// 	return root
// }

// type Node struct {
// 	Val    int
// 	Next   *Node
// 	Random *Node
// }

// func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
// 	if l1 == nil {
// 		return l2
// 	} else if l2 == nil {
// 		return l1
// 	}

// 	revl1 := reverseList(l1)
// 	revl2 := reverseList(l2)

// 	cnt := 0
// 	dump := &ListNode{}
// 	temp := dump
// 	for revl1 != nil || revl2 != nil {
// 		sum := cnt
// 		if revl1 != nil {
// 			sum += revl1.Val
// 			revl1 = revl1.Next
// 		}
// 		if revl2 != nil {
// 			sum += revl2.Val
// 			revl2 = revl2.Next
// 		}

// 		if sum >= 10 {
// 			cnt = 1
// 		} else {
// 			cnt = 0
// 		}
// 		node := &ListNode{Val: sum % 10}
// 		temp.Next = node
// 		temp = temp.Next
// 	}

// 	if cnt == 1 {
// 		node := &ListNode{
// 			Val: 1,
// 		}
// 		temp.Next = node
// 	}

// 	head := reverseList(dump.Next)
// 	return head
// }

// func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
// 	if l1 == nil {
// 		return l2
// 	} else if l2 == nil {
// 		return l1
// 	}

// 	revl1 := reverseList(l1)
// 	revl2 := reverseList(l2)
// 	cnt := 0
// 	for revl1 != nil && revl2 != nil {
// 		if revl1.Val+revl2.Val+cnt >= 10 {
// 			revl1.Val = (revl1.Val + revl2.Val + cnt) % 10
// 			cnt = 1
// 		} else {
// 			revl1.Val = revl1.Val + revl2.Val + cnt
// 			cnt = 0
// 		}
// 	}
// 	head := reverseList(revl1)
// 	return head
// }

// func copyRandomList(head *Node) *Node {
// 	if head == nil {
// 		return nil
// 	}
// 	cur := head
// 	for cur != nil {
// 		temp := cur.Next
// 		n := &Node{
// 			Val:  cur.Val,
// 			Next: temp,
// 		}
// 		cur.Next = n
// 		cur = temp
// 	}
// 	cur = head

// 	for cur != nil {
// 		if cur.Random == cur {
// 			cur.Next.Random = cur.Next
// 		} else {
// 			cur.Next.Random = cur.Random.Next
// 		}
// 		cur = cur.Next.Next
// 	}
// 	dump := &Node{}
// 	node := dump
// 	cur = head
// 	for cur != nil {
// 		node.Next = cur.Next
// 		cur = cur.Next.Next
// 		node = node.Next
// 	}
// 	return dump.Next
// }

// func listquestion(head *ListNode, m int) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	first := &ListNode{}
// 	firstend := &ListNode{}
// 	mid := &ListNode{}
// 	midend := &ListNode{}
// 	last := &ListNode{}
// 	lastend := &ListNode{}

// 	for head != nil {
// 		if head.Val < m {
// 			firstend.Next = head
// 			firstend = firstend.Next
// 		} else if head.Val == m {
// 			midend.Next = head
// 			midend = midend.Next
// 		} else {
// 			lastend.Next = head
// 			lastend = lastend.Next
// 		}
// 		head = head.Next
// 	}
// 	if last.Next != nil {
// 		midend.Next = last.Next
// 	}
// 	if mid.Next != nil {
// 		firstend.Next = mid.Next
// 	}
// 	return first.Next
// }

// func isPalindrome(head *ListNode) bool {
// 	if head == nil {
// 		return true
// 	}
// 	slow, fast := head, head
// 	for fast.Next != nil {
// 		slow = slow.Next
// 		fast = fast.Next
// 	}
// 	last := slow.Next
// 	slow.Next = nil
// 	rev := reverseList(last)
// 	for rev != nil && head != nil {
// 		if rev.Val != head.Val {
// 			return false
// 		}
// 		rev = rev.Next
// 		head = head.Next
// 	}
// 	return true
// }

// func reverseList(head *ListNode) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	var pre *ListNode
// 	for head != nil {
// 		temp := head.Next
// 		head.Next = pre
// 		pre = head
// 		head = temp
// 	}
// 	return pre
// }

// func listquestion(head *ListNode, n int) {
// 	if head == nil || head.Next == nil || n < 1 {
// 		return
// 	}
// 	last := head
// 	for last.Next != head {
// 		last = last.Next
// 	}
// 	cnt := 0
// 	for head.Next != head {
// 		if cnt+1 == n {
// 			cnt = 0
// 			last.Next = head.Next
// 			head = last.Next
// 		} else {
// 			head = head.Next
// 			last = last.Next
// 		}
// 		cnt++
// 	}
// 	fmt.Printf("%d ", head.Val)
// }

// func reverseBetween(head *ListNode, left int, right int) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	dump := &ListNode{}
// 	dump.Next = head
// 	var pre *ListNode
// 	start := dump
// 	last := dump
// 	for left != 0 {
// 		pre = head
// 		head = head.Next
// 		left--
// 	}
// 	start = head
// 	pre.Next = nil
// 	for right != 0 {
// 		head = head.Next
// 		right--
// 	}
// 	last = head.Next
// 	head.Next = nil
// 	k := reverseList(start)
// 	pre.Next = k
// 	start.Next = last
// 	return dump.Next
// }
// func reverseList(head *ListNode) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	var pre *ListNode
// 	for head != nil {
// 		temp := head.Next
// 		head.Next = pre
// 		pre = head
// 		head = temp
// 	}
// 	return pre
// }

// func reorderList(head *ListNode) {
// 	if head == nil {
// 		return
// 	}
// 	dump := &ListNode{}
// 	c := dump
// 	mid := findmidnode(head)
// 	revlast := reverseList(mid)
// 	for mid != nil && revlast != nil {
// 		c.Next = head
// 		head = head.Next
// 		c = c.Next
// 		c.Next = revlast
// 		revlast = revlast.Next
// 		c = c.Next
// 	}

// 	if head != nil {
// 		c.Next = head
// 	}
// 	if revlast != nil {
// 		c.Next = revlast
// 	}
// 	head = dump.Next
// }

// func reverseList(head *ListNode) *ListNode {
// 	var pre *ListNode

// 	for head != nil {
// 		temp := head.Next
// 		head.Next = pre
// 		pre = head
// 		head = temp
// 	}
// 	return pre
// }
// func findmidnode(head *ListNode) *ListNode {
// 	slow := head
// 	quick := head

// 	for quick.Next != nil && quick.Next.Next != nil {
// 		slow = slow.Next
// 		quick = quick.Next.Next
// 	}
// 	return slow.Next
// }

// func reverseList(head *ListNode) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	pre := &ListNode{}
// 	for head != nil {
// 		temp := head.Next
// 		head.Next = pre
// 		pre = head
// 		head = temp
// 	}
// 	return pre
// }

// func listquestion(list *List) *Node {
// 	head := list.head
// 	dump := &Node{}
// 	dump.next = head
// 	t := dump
// 	c := dump
// 	k := 0
// 	for t.next != nil {
// 		t = t.next
// 		k++
// 	}
// 	for k != 0 {
// 		c = c.next
// 	}
// 	c.next = c.next.next
// 	return dump.next
// }

// func listquestion(list *List, k int) {
// 	head := list.head

// 	dump := &Node{}
// 	dump.next = head
// 	t := dump
// 	for k != 0 {
// 		t = t.next
// 		k--
// 	}
// 	for t.next != nil {
// 		t = t.next
// 		dump = dump.next
// 	}
// 	dump.next = dump.next.next
// }
// func getKthFromEnd(head *ListNode, k int) *ListNode {

// 	dump := &ListNode{}
// 	dump.Next = head
// 	t := dump
// 	c := dump
// 	for k != 0 {
// 		t = t.Next
// 		k--
// 	}
// 	for t.Next != nil {
// 		t = t.Next
// 		c = c.Next
// 	}
// 	c.Next = c.Next.Next
// 	return dump.Next
// }
// func removeNthFromEnd(head *ListNode, n int) *ListNode {

// 	dump := &ListNode{}
// 	k := n
// 	dump.Next = head
// 	t := dump
// 	c := dump
// 	for k != 0 {
// 		t = t.Next
// 		k--
// 	}
// 	for t.Next != nil {
// 		t = t.Next
// 		c = c.Next
// 	}
// 	c.Next = c.Next.Next
// 	return dump.Next
// }

// func listquestion(list1 *List, list2 *List) {
// 	head1, head2 := list1.head, list2.head
// 	for head1 != nil && head2 != nil {
// 		if head1.value > head2.value {
// 			head1 = head1.next
// 		} else if head1.value == head2.value {
// 			head2 = head2.next
// 		} else {
// 			out.WriteString(fmt.Sprintf("%d ", head1.value))
// 			head1 = head1.next
// 			head2 = head2.next
// 		}
// 	}
// 	for head1 != nil {
// 		out.WriteString(fmt.Sprintf("%d ", head1.value))
// 		head1 = head1.next
// 	}
// 	for head2 != nil {
// 		out.WriteString(fmt.Sprintf("%d ", head2.value))
// 		head2 = head2.next
// 	}
// 	out.Flush()
// }

// type nodeX struct {
// 	nodes [2]*nodeX
// }

// func maxXorSub(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	res := nums[0]
// 	exo := nums[0]
// 	nodex := &nodeX{}
// 	nodex.add(exo)
// 	for i := 1; i < len(nums); i++ {
// 		exo ^= nums[i]
// 		nodex.add(exo)
// 		tmp := nodex.Seek(exo)
// 		res = max(res, tmp^exo)
// 	}
// 	return res
// }

// func (n *nodeX) add(value int) {
// 	cur := n
// 	for i := 31; i >= 0; i-- {
// 		k := (value >> i) & 1
// 		if cur.nodes[k] == nil {
// 			cur.nodes[k] = &nodeX{}
// 		}
// 		cur = cur.nodes[k]
// 	}
// }

// func (n *nodeX) Seek(value int) int {
// 	res := 0
// 	cnt := n
// 	for i := 31; i >= 0; i-- {
// 		k := (value >> i) & 1
// 		if i != 31 {
// 			k ^= 1
// 		}
// 		if cnt.nodes[k] != nil {
// 			res |= k << i
// 		} else {
// 			k ^= 1
// 			res |= k << i

// 		}
// 		cnt = cnt.nodes[k]
// 	}
// 	return res
// }

// func strQuestion(str string) int {
// 	if len(str) < 2 {
// 		return 0
// 	}
// 	dp := make([][]bool, len(str))
// 	f := make([]int, len(str))
// 	for i := 0; i < len(str); i++ {
// 		dp[i] = make([]bool, len(str))
// 	}
// 	for i := len(str) - 1; i >= 0; i-- {
// 		f[i] = math.MaxInt32
// 		for j := i; j < len(str); j++ {
// 			if str[i] == str[j] && (j-i < 2 || dp[i+1][j-1]) {
// 				f[i] = min(f[i], f[j+1]+1)
// 				dp[i][j] = true
// 			}
// 		}
// 	}

// 	return f[0]
// }

// func minWindow(str1 string, str2 string) string {
// 	if len(str1) < len(str2) {
// 		return ""
// 	}
// 	cnt := 0
// 	indexm := make(map[byte]int)
// 	for i := 0; i < len(str2); i++ {
// 		indexm[str2[i]]++
// 		cnt++
// 	}
// 	l, r := 0, 0
// 	res := math.MaxInt32
// 	str := ""

// 	for r < len(str1) {
// 		if v, ok := indexm[str1[r]]; ok {
// 			if v > 0 {
// 				cnt--
// 			}
// 			indexm[str1[r]]--
// 		}
// 		// fmt.Println(indexm, cnt, l, r, str)
// 		if cnt == 0 {
// 			if res > r-l+1 {
// 				res = r - l + 1
// 				str = str1[l : r+1]
// 			}
// 			for l <= r {
// 				if v, ok := indexm[str1[l]]; ok {
// 					if v+1 > 0 {
// 						cnt++
// 						indexm[str1[l]]++
// 						l++
// 						break
// 					} else {
// 						indexm[str1[l]]++
// 					}
// 				}
// 				l++
// 				if res > r-l+1 {
// 					res = r - l + 1
// 					str = str1[l : r+1]
// 				}
// 			}
// 		}
// 		r++
// 	}

// 	if res == math.MaxInt32 {
// 		return ""
// 	}
// 	return str
// }

// func k(m int) {
// 	time.Sleep(3 * time.Second)
// 	fmt.Println(m)
// }

// func strQuestion(str string, k int) string {
// 	n := k - 1
// 	cnt := 0

// 	for str[n] < 'a' {
// 		cnt++
// 		n--
// 	}

// 	if cnt%2 != 0 {
// 		return str[k-1 : k+1]
// 	} else {
// 		if str[k] >= 'a' {
// 			return string(str[k])
// 		} else {
// 			return str[k : k+2]
// 		}
// 	}
// }

// func lowerString(Strs []int) {
// 	sort.Slice(Strs, func(i, j int) bool {
// 		return Strs[i]+Strs[j] < Strs[j]+Strs[i]
// 	})
// 	res := ""
// 	for i := 0; i < len(Strs); i++ {
// 		res += Strs[i]
// 	}
// 	fmt.Println(res)
// }

// func strQuestion(str []int) int {
// 	if len(str) == 0 {
// 		return 0
// 	}
// 	res := 0
// 	strmap := make(map[int]int)
// 	l := -1

// 	for r := 0; r < len(str); r++ {
// 		if v, ok := strmap[str[r]]; ok {
// 			l = max(l, v)
// 		}
// 		res = max(res, r-l)
// 		strmap[str[r]] = r
// 	}
// 	return res
// }

// func (h hp64) Len() int            { return len(h) }
// func (h hp64) Less(i, j int) bool  { return h[i] < h[j] } // > 为最大堆
// func (h hp64) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
// func (h *hp64) Push(v interface{}) { *h = append(*h, v.(int)) }
// func (h *hp64) Pop() interface{}   { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }
// func (h *hp64) push(v int)         { heap.Push(h, v) }
// func (h *hp64) pop() int           { return heap.Pop(h).(int) }
// func (h *hp64) popPush(v int) int  { top := (*h)[0]; (*h)[0] = v; heap.Fix(h, 0); return top } // h 需要非空
// func (h *hp64) pushPop(v int) int {
// 	if len(*h) > 0 && v > (*h)[0] { // 最大堆改成 v < (*h)[0]
// 		v, (*h)[0] = (*h)[0], v
// 		heap.Fix(h, 0)
// 	}
// 	return v
// }

// func (h hp) Len() int {
// 	return len(h)
// }
// func (h hp) Less(i, j int) bool {
// 	return h[i] < h[j]
// }
// func (h *hp) Push(value interface{}) {
// 	*h = append(*h, value.(int))
// }

// func (h *hp) Pop() interface{} {
// 	x := *h
// 	k := x[len(x)-1]
// 	*h = x[:len(x)-1]
// 	return k
// }
// func (h hp) Swap(i, j int) {
// 	h[i], h[j] = h[j], h[i]
// }

// func MergeSort(nums []int) []int {
// 	return mergeSort(nums)
// }
// func mergeSort(nums []int) []int {
// 	if len(nums) <= 1 {
// 		return nums
// 	}
// 	mid := len(nums) / 2
// 	left := mergeSort(nums[:mid])
// 	right := mergeSort(nums[mid:])
// 	return merge(left, right)
// }

// func merge(left []int, right []int) []int {

// 	res := make([]int, 0)
// 	i, j := 0, 0
// 	for i < len(left) && j < len(right) {
// 		if left[i] < right[j] {
// 			res = append(res, left[i])
// 			i++
// 		} else {
// 			res = append(res, right[j])
// 			j++
// 		}
// 	}
// 	res = append(res, left[i:]...)
// 	res = append(res, right[j:]...)
// 	return res
// }

// func QuickSort(nums []int) []int {
// 	quickSort(nums, 0, len(nums)-1)
// 	return nums
// }

// func quickSort(nums []int, start, end int) {
// 	if start >= end {
// 		return
// 	}
// 	mid := partition1(nums, start, end)
// 	quickSort(nums, start, mid-1)
// 	quickSort(nums, mid+1, end)
// }

// func partition1(nums []int, start, end int) int {
// 	p := nums[end]

// 	i := start
// 	for j := start; j < end; j++ {
// 		if nums[j] < p {
// 			nums[j], nums[i] = nums[i], nums[j]
// 			i++
// 		}
// 	}
// 	nums[i], nums[end] = nums[end], nums[i]
// 	return i
// }

// func QuickSort(nums []int) []int {
// 	// 思路：把一个数组分为左右两段，左段小于右段
// 	quickSort(nums, 0, len(nums)-1)
// 	return nums
// }

// // 原地交换，所以传入交换索引
// func quickSort(nums []int, start, end int) {
// 	if start < end {
// 		// 分治法：divide
// 		pivot := partition(nums, start, end)
// 		quickSort(nums, 0, pivot-1)
// 		quickSort(nums, pivot+1, end)
// 	}
// }

// // 分区
// func partition(nums []int, start, end int) int {
// 	// 选取最后一个元素作为基准pivot
// 	p := nums[end]
// 	i := start
// 	// 最后一个值就是基准所以不用比较
// 	for j := start; j < end; j++ {
// 		if nums[j] < p {
// 			swap(nums, i, j)
// 			i++
// 		}
// 	}
// 	// 把基准值换到中间
// 	swap(nums, i, end)
// 	return i
// }

// // 交换两个元素
// func swap(nums []int, i, j int) {
// 	t := nums[i]
// 	nums[i] = nums[j]
// 	nums[j] = t
// }

// func strQuestion(str string) int {
// 	if len(str) == 0 {
// 		return 0
// 	}
// 	f := make([]int, len(str))

// 	for i := 0; i < len(str); i++ {
// 		if str[i] == '(' {
// 			f[i] = 0
// 		} else {
// 			if i-1 >= 0 && i-f[i-1]-1 >= 0 && str[i-f[i-1]-1] == '(' {
// 				f[i] = f[i-1] + 2
// 			}
// 			if i-f[i-1]-2 >= 0 {
// 				f[i] += f[i-f[i-1]-2]
// 			}
// 		}
// 	}
// 	return f[len(str)-1]
// }

// func strQuestion(str string) bool {
// 	if len(str) < 2 {
// 		return false
// 	}
// 	stack := make([]byte, 0)
// 	for i := 0; i < len(str); i++ {
// 		if str[i] != '(' && str[i] != ')' {
// 			return false
// 		} else if str[i] == '(' {
// 			stack = append(stack, str[i])
// 		} else {
// 			if len(stack) == 0 || stack[len(stack)-1] != '(' {
// 				return false
// 			} else {
// 				stack = stack[:len(stack)-1]
// 			}
// 		}
// 	}
// 	if len(stack) != 0 {
// 		return false
// 	}
// 	return false
// }

// func strQuestion(str string, target string) string {
// 	if len(str) == 0 {
// 		return ""
// 	}
// 	res := make([]byte, len(str)*2-len(target))
// 	l, r := 0, len(res)-1
// 	is, js := 0, len(str)-1
// 	it, jt := 0, len(target)-1
// 	for it <= jt && is <= js {
// 		if str[is] == target[it] && str[js] == target[jt] {
// 			res[l], res[r] = str[is], str[js]
// 			l, r = l+1, r-1
// 			is, js = is+1, js-1
// 			it, jt = it+1, jt-1
// 		} else {
// 			if str[is] != target[it] {
// 				res[l], res[r] = str[is], str[is]
// 				l, r = l+1, r-1
// 				is++
// 			}
// 			if str[js] != target[jt] {
// 				res[l], res[r] = str[js], str[js]
// 				l, r = l+1, r-1
// 				js--
// 			}
// 		}
// 	}
// 	// for is <= js {
// 	// 	res[l], res[r] = str[is], str[js]
// 	// 	l, r = l+1, r-1
// 	// 	is, js = is+1, js-1
// 	// }
// 	return string(res)
// }

// func strQuestion(str string) string {
// 	if len(str) == 0 {
// 		return ""
// 	}
// 	n := len(str)
// 	dp := make([][]int, n)
// 	for i := 0; i < len(dp); i++ {
// 		dp[i] = make([]int, n)
// 	}

// 	for i := n - 2; i >= 0; i-- {
// 		for j := i + 1; j < n; j++ {
// 			if str[i] == str[j] {
// 				dp[i][j] = dp[i+1][j-1]
// 			} else {
// 				dp[i][j] = min(dp[i+1][j], dp[i][j-1]) + 1
// 			}
// 		}
// 	}
// 	fmt.Println(dp)
// 	res := make([]byte, n+dp[0][n-1])
// 	i, j := 0, n-1
// 	l, r := 0, len(res)-1
// 	for l <= r {
// 		if str[i] == str[j] {
// 			res[l], res[r] = str[i], str[j]
// 			l, r, i, j = l+1, r-1, i+1, j-1

// 		} else {
// 			if dp[i+1][j] < dp[i][j-1] {
// 				res[l], res[r] = str[i], str[i]
// 				l, r, i = l+1, r-1, i+1
// 			} else {
// 				res[l], res[r] = str[j], str[j]
// 				l, r, j = l+1, r-1, j-1
// 			}
// 		}
// 	}

// 	return string(res)
// }

// func strQuestion(start string, end string, strs []string) int {
// 	if len(strs) == 0 || start == end {
// 		return 0
// 	}

// 	indexmap := make(map[string]map[string]struct{})
// 	for i := 0; i < len(strs); i++ {
// 		indexmap[strs[i]] = make(map[string]struct{}, 0)
// 	}
// 	indexmap[start] = make(map[string]struct{})
// 	indexmap[end] = make(map[string]struct{})
// 	for i := range indexmap {
// 		for j := 0; j < len(i); j++ {
// 			for k := 'a'; k <= 'z'; k++ {
// 				s := i[:j] + string(k) + i[j+1:]
// 				if _, ok := indexmap[s]; ok && s != i {
// 					indexmap[i][s] = struct{}{}
// 				}
// 			}
// 		}
// 	}
// 	fmt.Println(indexmap)
// 	return 0
// }

// func strs(strs []string, str1 string, str2 string) int {
// 	if str1 == "" || str2 == "" {
// 		return -1
// 	}
// 	if str1 == str2 {
// 		return 0
// 	}

// 	l, r := -1, -1
// 	res := math.MaxInt32
// 	for i := 0; r < len(strs); i++ {
// 		if strs[i] == str1 {
// 			l = i
// 		} else if strs[i] == str2 {
// 			r = i
// 		}
// 		if l != -1 && r != -1 {
// 			if r-l > 0 {
// 				res = min(res, r-l)
// 			} else {
// 				res = min(res, l-r)
// 			}
// 		}
// 	}
// 	if r == -1 || l == -1 {
// 		return -1
// 	}
// 	return res
// }

// type Person struct {
// 	age int
// }

// func (p Person) howOld() int {
// 	return p.age
// }
// func (p Person) growUp() {
// 	p.age += 1
// }
// func main() {
// 	// qcrao 是值类型
// 	qcrao := Person{age: 18}
// 	// 值类型 调用接收者也是值类型的方法
// 	fmt.Println(qcrao.howOld())
// 	// 值类型 调用接收者是指针类型的方法
// 	qcrao.growUp()
// 	fmt.Println(qcrao.howOld())
// 	// ----------------------
// 	// stefno 是指针类型
// 	stefno := &Person{age: 100}
// 	// 指针类型 调用接收者是值类型的方法
// 	fmt.Println(stefno.howOld())
// 	// 指针类型 调用接收者也是指针类型的方法
// 	stefno.growUp()
// 	fmt.Println(stefno.howOld())
// }

// func strQuestion(str string) string {
// 	indexm := make(map[byte]int)
// 	res := ""
// 	for i := 0; i < len(str); i++ {
// 		indexm[str[i]-'a']++
// 	}
// 	l, r := 0, 0
// 	for r < len(str) {
// 		if indexm[str[r]-'a'] == -1 || indexm[str[r]-'a']-1 > 0 {
// 			indexm[str[r]-'a'] -= 1
// 			r++
// 		} else {
// 			index := -1
// 			for i := l; i <= r; i++ {
// 				if indexm[str[i]-'a'] != -1 && (index == -1 || str[i] < str[index]) {
// 					index = i
// 				}
// 			}
// 			res += string(str[index])
// 			for i := index + 1; i <= r; i++ {
// 				if indexm[str[i]-'a'] != -1 {
// 					indexm[str[i]-'a']++
// 				}
// 			}
// 			l = index + 1
// 			r = l
// 			indexm[str[index]] = -1
// 		}
// 	}
// 	return res
// }

// func strQuestion(str string) int {
// 	maxvalue := -1 * math.MinInt32
// 	flag := false
// 	if str[0] == '0' {
// 		return 0
// 	} else if str[0] == '-' {
// 		flag = true
// 		str = str[1:]
// 	}
// 	if str[0] == '0' {
// 		return 0
// 	}
// 	res := 0
// 	for i := 0; i < len(str); i++ {
// 		if str[i]-'0' < 0 || str[i]-'0' > 9 {
// 			return 0
// 		}
// 		res = res*10 + int(str[i]-'0')
// 		if flag && res > maxvalue || !flag && res > maxvalue-1 {
// 			return 0
// 		}
// 	}
// 	if flag {
// 		return res * -1
// 	}
// 	return res
// }

// func strQuestion(str1, str2 string) bool {
// 	if len(str1) != len(str2) {
// 		return false
// 	}
// 	s := str1[0]
// 	index := 0
// 	for i := 0; i < len(str2); i++ {
// 		if str2[i] == s {
// 			index = i
// 			break
// 		}
// 	}
// 	sbyte := string([]byte(str2)[index:]) + string([]byte(str2)[:index])
// 	if sbyte == str1 {
// 		return true
// 	}
// 	return false
// }

// func strQuestion(str1, str2 string) bool {
// 	if len(str1) != len(str2) {
// 		return false
// 	}
// 	nums := make([]int, 10)

// 	for i := 0; i < len(str1); i++ {
// 		nums[str1[i]-'0']++
// 		nums[str1[i]-'0']--
// 	}
// 	for i := 0; i < len(nums); i++ {
// 		if nums[i] != 0 {
// 			return false
// 		}
// 	}
// 	return true
// }

// func maximumInvitations(favorite []int) int {
// 	if len(favorite) == 0 {
// 		return 0
// 	}
// 	indexm := make(map[int]int)
// 	for i := 0; i < len(favorite); i++ {
// 		indexm[favorite[i]]++
// 	}
// }

// func asteroidsDestroyed(mass int, asteroids []int) bool {
// 	nums := make([]int, 0)
// 	i, j := 0, len(asteroids)-1

// 	for ; i < len(nums); i++ {
// 		if mass >= asteroids[i] {
// 			mass += asteroids[i]

// 		} else {
// 			left, right := i, j
// 			for left < right {
// 				mid := (left + right) / 2
// 				if asteroids[mid] <= mass {
// 					asteroids[i], asteroids[mid] = asteroids[mid], asteroids[i]
// 					mass += asteroids[i]
// 					break
// 				} else {
// 					right = mass
// 				}
// 			}
// 		}
// 	}
// }

// func asteroidsDestroyed(mass int, asteroids []int) bool {
// 	sort.Ints(asteroids)

// 	for i := 0; i < len(asteroids); i++ {
// 		if mass < asteroids[i] {
// 			return false
// 		} else {
// 			mass += asteroids[i]
// 		}
// 	}
// 	return true
// }

// func checkString(s string) bool {
// 	flag := false

// 	for i := 0; i < len(s); i++ {
// 		if s[i] == 'b' {
// 			flag = true
// 		} else if s[i] == 'a' && flag {
// 			return false
// 		}
// 	}
// 	return true
// }

// func numberOfBeams(bank []string) int {
// 	nums := make([]int, len(bank))
// 	for i := 0; i < len(bank); {
// 		cnt := 0
// 		for j := 0; j < len(bank[i]); j++ {
// 			if bank[i][j] == '1' {
// 				cnt++
// 			}
// 		}
// 		nums[i] = cnt
// 	}
// 	res := 0
// 	index := 0
// 	for i := 1; i < len(nums); i++ {
// 		if nums[i] != 0 {
// 			res += nums[index] * nums[i]
// 			index = i
// 		}
// 	}
// 	return res
// }

// func goroutineA(a <-chan int) {
// 	val := <-a
// 	fmt.Println("G1 received data: ", val)
// 	return
// }
// func goroutineB(b <-chan int) {
// 	val := <-b
// 	fmt.Println("G2 received data: ", val)
// 	return
// }
// func main() {
// 	ch := make(chan int)

// 	go goroutineB(ch)
// 	go goroutineA(ch)
// 	ch <- 3
// 	ch <- 3
// 	time.Sleep(3 * time.Second)
// }

// type V struct {
// 	i int64
// 	k int32
// 	j int64
// }

// type user struct {
// 	name string
// 	age  int8
// }

// var u = user{name: "Ankur", age: 25}
// var g = &u

// func modifyUser(pu *user) {
// 	fmt.Println("modifyUser Received Vaule", pu)
// 	pu.name = "Anand"
// }
// func printUser(u <-chan *user) {
// 	time.Sleep(2 * time.Second)
// 	fmt.Println("printUser goRoutine called", <-u)
// }
// func main() {
// 	c := make(chan *user, 5)
// 	c <- g
// 	fmt.Println(g)
// 	// modify g
// 	g = &user{name: "Ankur Anand", age: 100}
// 	u.name = "haha"
// 	go printUser(c)
// 	go modifyUser(g)
// 	time.Sleep(5 * time.Second)
// 	fmt.Println(g)
// }

// func main() {
// 	var v *V = new(V)                          //得到结构v的指针
// 	var i *int32 = (*int32)(unsafe.Pointer(v)) //这里指向结构体的初试位置转换为int32类型指针是指向v.i的指针
// 	*i = int32(98)
// 	var j *int64 = (*int64)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + uintptr(unsafe.Offsetof(v.j)))) //加4个字节的指针偏移得到j
// 	*j = int64(763)
// 	fmt.Println(v)
// 	fmt.Println(uintptr(unsafe.Alignof(v)))
// }

// func getWater(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	res := 0
// 	leftmax := make([]int, len(nums))
// 	rightmax := make([]int, len(nums))
// 	for i := 1; i < len(nums)-1; i++ {
// 		leftmax[i] = max(leftmax[i-1], nums[i-1])
// 		rightmax[len(nums)-1-i] = max(rightmax[len(nums)-i], nums[len(nums)-i])
// 	}

// 	for i := 1; i < len(nums)-1; i++ {
// 		res += max(min(leftmax[i], rightmax[i])-nums[i], 0)
// 	}
// 	return res
// }

// func missNum(nums []int) int {
// 	l := 0
// 	r := len(nums)

// 	for l < r {
// 		if nums[l] == l+1 {
// 			l++
// 		} else if nums[l] < l || nums[l] > r || nums[nums[l]-1] == nums[l] {
// 			nums[l] = nums[r-1]
// 			r--
// 		} else {
// 			nums[l], nums[nums[l]-1] = nums[nums[l]-1], nums[l]
// 		}
// 	}
// 	return l + 1
// }

// func matrix(nums [][]int) int {
// 	res := 0
// 	indexm := make(map[int]map[int]int)
// 	indexm[0] = make(map[int]int)
// 	indexm[0][0] = 1
// 	rq := []int{0}
// 	cq := []int{0}
// 	r, c := 0, 0
// 	for len(rq) != 0 {
// 		r, c = rq[0], cq[0]
// 		rq, cq = rq[1:], cq[1:]
// 		if r == len(nums)-1 && c == len(nums[0])-1 {
// 			return indexm[r][c]
// 		}
// 		walk(indexm[r][c], r-1, c, nums, indexm, &rq, &cq)
// 		walk(indexm[r][c], r+1, c, nums, indexm, &rq, &cq)
// 		walk(indexm[r][c], r, c-1, nums, indexm, &rq, &cq)
// 		walk(indexm[r][c], r, c+1, nums, indexm, &rq, &cq)
// 	}
// 	return res
// }

// func walk(pre, r, c int, nums [][]int, indexm map[int]map[int]int, rq, cq *[]int) {
// 	if r < 0 || r == len(nums) || c < 0 || c == len(nums[0]) || indexm[r][c] != 0 || nums[r][c] != 1 {
// 		return
// 	}
// 	if _, ok := indexm[r]; !ok {
// 		indexm[r] = make(map[int]int)
// 	}
// 	indexm[r][c] = pre + 1
// 	*rq = append(*rq, r)
// 	*cq = append(*cq, c)
// }

// func PartitionSwapMid(nums []int, k int) {
// 	l, r := -1, len(nums)
// 	index := 0
// 	for index < r {
// 		if nums[index] < k {
// 			nums[index], nums[l+1] = nums[l+1], nums[index]
// 			l++
// 		} else if nums[index] > k {
// 			nums[index], nums[r-1] = nums[r-1], nums[index]
// 			r--
// 		}
// 		index++
// 	}
// 	fmt.Println(nums)
// }

// func PartitionSwap(nums []int) {
// 	l := 0
// 	r := 1
// 	for r < len(nums) {
// 		if nums[r] == nums[l] {

// 			r++
// 		} else {
// 			nums[l+1], nums[r] = nums[r], nums[l+1]
// 			l += 1
// 			r += 1
// 		}
// 	}
// 	for i := 0; i < len(nums); i++ {
// 		out.WriteString(fmt.Sprintf("%d ", nums[i]))
// 	}
// 	out.Flush()
// }

// func matrix(nums []int, k int) {
// 	res := make([]int, len(nums))
// 	res[0] = nums[1]
// 	for i := 1; i < len(nums); i++ {
// 		res[i] = nums[i] * res[i-1]
// 	}
// 	temp := 1
// 	for i := len(nums) - 1; i > 0; i-- {
// 		res[i] = (res[i-1] * temp) % k
// 		temp *= nums[i]
// 	}
// 	res[0] = temp
// 	for i := 0; i < len(nums); i++ {
// 		out.WriteString(fmt.Sprintf("%d ", res[i]))
// 	}
// 	out.Flush()
// }

// func matrix(nums []int, k int) {
// 	// res := make([]int, len(nums))
// 	sum := 1
// 	for i := 0; i < len(nums); i++ {
// 		sum *= nums[i]
// 	}
// 	for i := 0; i < len(nums); i++ {
// 		out.WriteString(fmt.Sprintf("%d ", (sum/nums[i])%k))
// 	}
// 	out.Flush()
// }

// func matrix(nums [][]int) int {
// 	if len(nums) == 0 || len(nums[0]) == 0 {
// 		return 0
// 	}
// 	res := 0
// 	n := len(nums)
// 	m := len(nums[0])
// 	right := make([][]int, n)
// 	down := make([][]int, n)
// 	for i := 0; i < n; i++ {
// 		right[i] = make([]int, m)
// 		down[i] = make([]int, m)
// 	}

// 	for i := 0; i < n; i++ {
// 		if nums[i][m-1] == 1 {
// 			right[i][m-1] = 1
// 		} else {
// 			right[i][m-1] = 0
// 		}
// 		for j := m - 2; j >= 0; j-- {
// 			if nums[i][j] == 1 {
// 				right[i][j] = right[i][j+1] + 1
// 			} else {
// 				right[i][j] = 0
// 			}
// 		}
// 	}
// 	for i := 0; i < m; i++ {
// 		if nums[n-1][i] == 1 {
// 			down[n-1][i] = 1
// 		} else {
// 			down[n-1][i] = 0
// 		}
// 		for j := n - 2; j >= 0; j-- {
// 			if nums[j][i] == 1 {
// 				down[j][i] = down[j+1][i] + 1
// 			} else {
// 				down[j][i] = 0
// 			}
// 		}
// 	}

// 	for i := 0; i < n; i++ {
// 		for j := 0; j < m; j++ {
// 			if nums[i][j] == 0 {
// 				continue
// 			}
// 			limit := min(n-i, m-j)

// 			for k := limit - 1; k >= 0; k-- {
// 				if right[i][j] > k && down[i][j] > k && down[i][j+k] > k && right[i+k][j] > k {
// 					res = max(res, k+1)
// 					break
// 				}else if k <
// 			}
// 		}
// 	}
// 	return res
// }

// func maxProduct(nums []int) int {
// 	maxvalue := nums[0]
// 	minvalue := nums[0]
// 	res := nums[0]

// 	for i := 1; i < len(nums); i++ {
// 		tmax := maxvalue * nums[i]
// 		tmin := minvalue * nums[i]
// 		maxvalue = max(tmax, max(tmin, nums[i]))
// 		minvalue = min(tmax, min(tmin, nums[i]))
// 		res = max(res, maxvalue)
// 	}
// 	return res
// }

// func getlessIndex(nums []int) int {
// 	if len(nums) == 0 {
// 		return -1
// 	} else if len(nums) == 1 || nums[0] < nums[1] {
// 		return 0
// 	} else if nums[len(nums)-2] > nums[len(nums)-1] {
// 		return len(nums) - 1
// 	}
// 	l := 1
// 	r := len(nums) - 2
// 	for l < r {
// 		mid := (l + r) / 2
// 		if nums[mid] > nums[mid-1] {
// 			r = mid - 1
// 		} else if nums[mid] > nums[mid+1] {
// 			l = mid + 1
// 		} else {
// 			return mid
// 		}
// 	}
// 	return l
// }

// func matrixSum(nums [][]int) int {
// 	res := 0

// 	for i := 0; i < len(nums); i++ {
// 		sum := make([]int, len(nums[0]))
// 		for j := i; j < len(nums); j++ {
// 			for k := 0; k < len(nums[0]); k++ {
// 				sum[k] += nums[j][k]
// 			}
// 			result := matrix(sum)
// 			res = max(res, result)
// 		}
// 	}
// 	return res
// }

// func matrix(nums []int) int {
// 	res := 0
// 	now := nums[0]

// 	for i := 1; i < len(nums); i++ {
// 		now = max(now+nums[i], nums[i])
// 		res = max(res, now)
// 	}
// 	return res
// }

// func matrixSort(nums []int) {
// 	b := 0
// 	n := len(nums)

// 	for b < n {
// 		if (b%2 != 0 && nums[b] % 2 != 0) || (b%2 == 0 && nums[b]%2 == 0){ //奇数
// 			b++
// 		}else{
// 			if nums[b]%2 != 0 {

// 			} else {
// 				index := b + 1
// 				for index < n && nums[b]%2 == 0 {
// 					if nums[index]%2 == 0 {
// 						index += 2
// 						continue
// 					}
// 					nums[b], nums[index] = nums[index], nums[b]
// 				}
// 			}
// 		}
// 	}
// }

// func matrixSort(nums []int) {
// 	for i := 0; i < len(nums); i++ {
// 		if (i%2 == 0 && nums[i]%2 == 0) || (i%2 != 0 && nums[i]%2 != 0) {
// 			continue
// 		}
// 		temp := i + 1
// 		if i%2 == 0 {
// 			for temp < len(nums) && nums[temp]%2 != 0 {
// 				temp += 2
// 			}
// 		} else {
// 			for temp < len(nums) && nums[temp]%2 == 0 {
// 				temp += 2
// 			}
// 		}
// 		if temp < len(nums) {
// 			nums[i], nums[temp] = nums[temp], nums[i]
// 		}
// 		out.WriteString(fmt.Sprintf("%d ", nums[i]))
// 	}

// 	out.Flush()
// }

// func getSmallSum(arr []int) int {
// 	if len(arr) == 0 {
// 		return 0
// 	}
// 	return dfs(arr, 0, len(arr)-1)
// }
// func dfs(arr []int, l, r int) int {
// 	if l == r {
// 		return 0
// 	}
// 	mid := (l + r) / 2
// 	return dfs(arr, l, mid) + dfs(arr, mid+1, r) + merge(arr, l, mid, r)
// }

// func merge(arr []int, l, mid, r int) int {
// 	h := make([]int, len(arr))
// 	index := 0
// 	res := 0
// 	left := l
// 	right := mid + 1

// 	for left <= mid && right <= r {
// 		if arr[left] <= arr[right] {
// 			res += arr[left] * (r - right + 1)
// 			h[index] = arr[left]
// 			index++
// 			left++
// 		} else {
// 			h[index] = arr[right]
// 			index++
// 			right++
// 		}
// 	}
// 	for ; right < r+1 || left < mid+1; left, right = left+1, right+1 {
// 		if left < mid+1 {
// 			h[index] = arr[left]
// 		} else {
// 			h[index] = arr[right]
// 		}
// 		index++
// 	}
// 	for i := 0; i < len(arr); i++ {
// 		arr[i] = h[i]
// 	}
// 	return res
// }

// func Lowervalue(nums []int, k int) int {
// 	index := make([]int, len(nums)+1)

// 	sum := 0
// 	for i := 0; i < len(nums); i++ {
// 		sum += nums[i]
// 		index[i+1] = max(index[i], sum)
// 	}
// 	sum = 0
// 	res := 0
// 	for i := 0; i < len(nums); i++ {
// 		sum += nums[i]
// 		l, r := 0, len(index)-1
// 		d := sum - k
// 		tmp := -1
// 		for l <= r {
// 			mid := (l + r) / 2
// 			if index[mid] >= d {
// 				r = mid - 1
// 				tmp = mid
// 			} else {
// 				l = mid + 1
// 			}
// 		}
// 		if tmp != -1 {
// 			res = max(res, i-tmp+1)
// 		}
// 	}
// 	return res
// }

// func MaxLenSum(nums []int, k int) int {
// 	l, r := 0, 0
// 	sum := nums[0]
// 	res := 0
// 	for r < len(nums) {
// 		if sum == k {
// 			res = max(res, r-l+1)
// 			sum -= nums[l]
// 			l++
// 		} else if sum < k {
// 			r++
// 			if r == len(nums) {
// 				break
// 			}
// 			sum += nums[r]
// 		} else {
// 			sum -= nums[l]
// 			l++
// 		}
// 	}
// 	return res
// }

// func MaxLenSum(nums []int, k int) int {
// 	indexm := make(map[int]int)
// 	sum := 0
// 	indexm[0] = -1
// 	res := 0
// 	for i := 0; i < len(nums); i++ {
// 		sum += nums[i]
// 		if _, ok := indexm[sum]; !ok {
// 			indexm[sum] = i
// 		}
// 		if v, ok := indexm[sum-k]; ok {
// 			res = max(res, i-v)
// 		}

// 	}
// 	return res
// }

// func PrintfValueMatrix(nums []int, target int) {
// 	if len(nums) < 3 {
// 		return
// 	}
// 	for i := 0; i < len(nums)-2; i++ {
// 		if i == 0 || nums[i] != nums[i-1] {
// 			l := i + 1
// 			r := len(nums) - 1
// 			for l < r {
// 				fmt.Println(nums[i], nums[l], nums[r], i, l, r)
// 				if nums[r]+nums[l]+nums[i] < target {
// 					l++
// 				} else if nums[r]+nums[l]+nums[i] > target {
// 					r--
// 				} else {
// 					if l == i+1 || nums[l] != nums[l-1] {
// 						out.WriteString(fmt.Sprintf("%d %d %d\n", nums[i], nums[l], nums[r]))
// 					}
// 					l++
// 					r--
// 				}
// 			}
// 		}
// 	}
// 	out.Flush()
// }

// func PrintfValueMatrix(nums []int, target int) {
// 	l := 0

// 	n := len(nums)
// 	for i := 0; i < n-2; i++ {
// 		for i < n-2 && nums[i] == nums[i+1] {
// 			i++
// 		}
// 		l = i + 1
// 		r := len(nums) - 1

// 		for l < r {
// 			if nums[l]+nums[r]+nums[i] == target && nums[r] != nums[l] {
// 				out.WriteString(fmt.Sprintf("%d %d %d\n", nums[i], nums[l], nums[r]))
// 				l++
// 				r--
// 			} else if nums[l]+nums[r]+nums[i] < target {
// 				l++
// 			} else {
// 				r--
// 			}
// 		}
// 	}

// 	out.Flush()
// }
// func PrintfValueMatrix(nums []int, target int) {
// 	l := 0

// 	res := make([][]int, 0)
// 	n := len(nums)
// 	for i := 0; i < n-2; i++ {
// 		for i < n-2 && nums[i] == nums[i+1] {
// 			i++
// 		}
// 		l = i + 1
// 		r := len(nums) - 1

// 		for l < r {
// 			if nums[l]+nums[r]+nums[i] == target && nums[r] != nums[l] {
// 				k := []int{nums[i], nums[l], nums[r]}
// 				res = append(res, k)
// 				rt := r
// 				lt := l
// 				for r != l && nums[r] == nums[rt] {
// 					r--
// 				}
// 				for r != l && nums[l] == nums[lt] {
// 					lt++
// 				}
// 			} else if nums[l]+nums[r]+nums[i] < target {
// 				l++
// 			} else {
// 				r--
// 			}
// 		}
// 	}

// 	for i := 0; i < len(res); i++ {
// 		out.WriteString(fmt.Sprintf("%d %d %d\n", res[i][0], res[i][1], res[i][2]))
// 	}
// 	out.Flush()
// }

// func PrintfValueMatrix(nums []int, target int) {
// 	l := 0
// 	r := len(nums) - 1
// 	res := make([][]int, 0)
// 	for l < r {
// 		if nums[l]+nums[r] == target {
// 			k := []int{nums[l], nums[r]}
// 			res = append(res, k)
// 			rt := r
// 			lt := l
// 			for r != l && nums[r] == nums[rt] {
// 				r--
// 			}
// 			for r != l && nums[l] == nums[lt] {
// 				lt++
// 			}
// 		} else if nums[l]+nums[r] < target {
// 			l++
// 		} else {
// 			r--
// 		}
// 	}
// 	for i := 0; i < len(res); i++ {
// 		out.WriteString(fmt.Sprintf("%d %d\n", res[i][0], res[i][1]))
// 	}
// 	out.Flush()
// }

// func MaxLenMatrix(nums []int) int {
// 	minvalue := 0
// 	maxvalue := 0
// 	res := 0

// 	n := len(nums)
// 	for i := 0; i < n; i++ {
// 		minvalue = math.MaxInt32
// 		maxvalue = math.MinInt32
// 		indexmap := make(map[int]bool)
// 		for j := i; j < n; j++ {
// 			if _, ok := indexmap[nums[j]]; ok {
// 				break
// 			}
// 			indexmap[nums[j]] = true
// 			minvalue = min(minvalue, nums[j])
// 			maxvalue = max(maxvalue, nums[j])
// 			if maxvalue-minvalue == j-i {
// 				res = max(res, j-i+1)
// 			}
// 		}
// 	}
// 	return res
// }

// func FindNumMatrix(nums [][]int, target int) bool {
// 	x, y := 0, len(nums[0])-1
// 	n := len(nums) - 1
// 	for x < n && y >= 0 {
// 		if nums[x][y] == target {
// 			return true
// 		} else if nums[x][y] > target {
// 			x--
// 		} else {
// 			y++
// 		}
// 	}
// 	return false
// }

// func getDistances(a []int) (ans []int64) {
// 	mapindexs := map[int][]int{}

// 	for i := 0; i < len(a); i++ {
// 		mapindexs[a[i]] = append(mapindexs[a[i]], i)
// 	}

// 	result := make([]int64, len(a))

// 	for _, v := range mapindexs {
// 		sum := 0
// 		left, right := len(v)-1, 0

// 		for j := 1; j < len(v); j++ {
// 			sum += v[j] - v[0]
// 		}
// 		result[v[0]] = int64(sum)

// 		for j := 1; j < len(v); j++ {
// 			left -= 1
// 			right += 1
// 			sum += (right - 1) * (v[j] - v[j-1])
// 			sum -= left * (v[j] - v[j-1])
// 			result[v[j]] = int64(sum)
// 		}
// 	}
// 	return result
// }

// func executeInstructions(n int, startPos []int, s string) []int {
// 	matrix := make([][]int, n)
// 	for i := 0; i < n; i++ {
// 		matrix[i] = make([]int, n)
// 	}
// 	res := make([]int, len(s))
// 	x, y := startPos[0], startPos[1]
// 	for i := 0; i < len(s); i++ {
// 		cnt := 0
// 		for j := i; j < len(s); j++ {
// 			fmt.Println(x, y, cnt)
// 			if s[j] == 'L' {
// 				if y-1 >= 0 {
// 					cnt++
// 					y -= 1
// 				} else {
// 					break
// 				}
// 			} else if s[j] == 'R' {
// 				if y+1 < n {
// 					cnt++
// 					y += 1
// 				} else {
// 					break
// 				}
// 			} else if s[j] == 'U' {
// 				if x-1 >= 0 {
// 					cnt++
// 					x -= 1
// 				} else {
// 					break
// 				}
// 			} else if s[j] == 'D' {
// 				if x+1 < n {
// 					cnt++
// 					x += 1
// 				} else {
// 					break
// 				}
// 			}
// 		}

// 		x, y = startPos[0], startPos[1]
// 		res[i] = cnt
// 	}
// 	return res
// }

// func isSameAfterReversals(num int) bool {
// 	if num == 0 {
// 		return true
// 	}
// 	if num%10 == 0 {
// 		return false
// 	}
// 	return true
// 	// reversed1 := make([]int, 0)
// 	// reversed2 := make([]int, 0)
// 	// for num != 0 {
// 	// 	value := num % 10
// 	// 	num = num / 10
// 	// 	reversed1 = append(reversed1, value)
// 	// 	reversed2 = append([]int{value}, reversed2...)
// 	// }
// 	// for {
// 	// 	if len(reversed1) != 0 && reversed1[0]
// 	// }
// }

// func numSubarraysWithSum(nums []int, goal int) int {
// 	summap := make(map[int]int)

// 	res := 0
// 	summap[0] = 1
// 	all := 0
// 	for i := 0; i < len(nums); i++ {
// 		all += nums[i]
// 		if v, ok := summap[all-goal]; ok {
// 			res += v
// 		}
// 		summap[all]++
// 	}
// 	return res
// }

// func matricFind(nums [][]int, target int) bool {
// 	n := len(nums)
// 	m := len(nums[0]) - 1
// 	i, j := m, 0
// 	for i >= 0 && j < n {
// 		if nums[i][j] == target {
// 			return true
// 		} else if nums[i][j] > target {
// 			i--
// 		} else {
// 			j++
// 		}
// 	}
// 	return false
// }

// func FindNumK(nums []int, k int) {
// 	values := make(map[int]int)
// 	n := len(nums)
// 	for i := 0; i < n; i++ {
// 		if _, ok := values[nums[i]]; ok {
// 			values[nums[i]]++
// 		} else {
// 			if len(values) < k-1 {
// 				values[nums[i]] = 1
// 			} else {
// 				for v := range values {
// 					values[v]--
// 					if values[v] == 0 {
// 						delete(values, v)
// 					}
// 				}
// 			}
// 		}
// 	}

// 	for k := range values {
// 		values[k] = 0
// 	}
// 	for i := 0; i < n; i++ {
// 		if _, ok := values[nums[i]]; ok {
// 			values[nums[i]]++
// 		}
// 	}

// 	flag := false
// 	for k, v := range values {
// 		if v > n/k {
// 			flag = true
// 			out.WriteString(fmt.Sprintf("%d ", k))
// 		}
// 	}
// 	if !flag {
// 		out.WriteString(fmt.Sprintf("%d ", -1))
// 	}
// 	out.Flush()
// }

// func FindNumhalf(nums []int) int {
// 	cnt := 0
// 	value := 0
// 	n := len(nums)
// 	for i := 0; i < n; i++ {
// 		if cnt == 0 {
// 			cnt++
// 			value = nums[i]
// 		} else {
// 			if value == nums[i] {
// 				cnt++
// 			} else {
// 				cnt--
// 			}
// 		}
// 	}
// 	cnt = 0
// 	for i := 0; i < n; i++ {
// 		if value == nums[i] {
// 			cnt++
// 		}
// 	}
// 	if cnt > n/2 {
// 		return value
// 	}
// 	return -1
// }

// func needTosort(nums []int) int {
// 	minindex := -1
// 	maxindex := len(nums)
// 	minvalue := math.MaxInt32
// 	maxvalue := math.MinInt32
// 	for i := len(nums) - 1; i >= 0; i-- {
// 		if nums[i] < minvalue {
// 			minvalue = nums[i]
// 		}
// 		if nums[i] > minvalue {
// 			minindex = i
// 		}
// 	}
// 	if minindex == -1 {
// 		return 0
// 	}
// 	for i := 0; i < len(nums); i++ {
// 		if nums[i] > maxvalue {
// 			maxvalue = nums[i]
// 		}
// 		if nums[i] < maxvalue {
// 			maxindex = i
// 		}
// 	}
// 	return maxindex - minindex + 1
// }

// func Zmatrix(nums [][]int) {
// 	tR, tC := 0, 0
// 	dR, dC := 0, 0
// 	endR, endC := len(nums), len(nums[0])
// 	flag := false
// 	for tR != endR {
// 		PrintfZmatrix(nums, tR, tC, dR, dC, flag)
// 		if tC < endC-1 {
// 			tC++
// 		} else {
// 			tR++
// 		}
// 		if dR < endR-1 {
// 			dR++
// 		} else {
// 			dC++
// 		}
// 		flag = !flag
// 	}
// }
// func PrintfZmatrix(nums [][]int, tR, tC, dR, dC int, flag bool) {
// 	if flag {
// 		for tR <= dR {
// 			fmt.Printf("%d ", nums[tR][tC])
// 			tR++
// 			tC--
// 		}
// 	} else {
// 		for dR >= tR {
// 			fmt.Printf("%d ", nums[dR][dC])
// 			dR--
// 			dC++
// 		}
// 	}
// }

// func rotatenums(nums [][]int) [][]int {
// 	if len(nums) == 0 {
// 		return nil
// 	}
// 	lline, lcolumn := 0, 0
// 	rline, rcolumn := len(nums)-1, len(nums[0])-1

// 	for lline < rline{
// 		rotate(nums, lline, lcolumn, rline, rcolumn)
// 		lline += 1
// 		lcolumn += 1
// 		rline -= 1
// 		rcolumn -= 1
// 	}
// 	return nums
// }

// func rotate(nums [][]int, lline, lcolumn, rline, rcolumn int) {
// 	ll, lc, rl, rc := lline, lcolumn, rline, rcolumn
// 	for i := lcolumn; i < rcolumn; i++ {
// 		nums[ll][lc+i], nums[ll+i][rc], nums[rl][rc-i], nums[rl-i][lc] = nums[rl-i][lc], nums[ll][lc+i], nums[ll+i][rc], nums[rl][rc-i]
// 	}
// }

// func SpiralOrder(nums [][]int) {
// 	if len(nums) == 0 {
// 		return
// 	}
// 	lline, lcolumn := 0, 0
// 	rline, rcolumn := len(nums)-1, len(nums[0])-1

// 	for lline <= rline && lcolumn <= rcolumn {
// 		printnums(nums, lline, lcolumn, rline, rcolumn)
// 		lline += 1
// 		lcolumn += 1
// 		rline -= 1
// 		rcolumn -= 1
// 	}
// }
// func printnums(nums [][]int, lline, lcolumn, rline, rcolumn int) {
// 	if lline == rline {
// 		for i := lcolumn; i <= rcolumn; i++ {
// 			fmt.Printf("%d ", nums[lline][i])
// 		}
// 	} else if lcolumn == rcolumn {
// 		for i := lline; i <= rline; i++ {
// 			fmt.Printf("%d ", nums[i][lcolumn])
// 		}
// 	} else {
// 		tll, tlc := lline, lcolumn
// 		rll, rlc := rline, rcolumn

// 		for ; tlc < rlc; tlc++ {
// 			fmt.Printf("%d ", nums[tll][tlc])
// 		}
// 		for ; tll < rll; tll++ {
// 			fmt.Printf("%d ", nums[tll][tlc])
// 		}
// 		for ; tlc > lcolumn; tlc-- {
// 			fmt.Printf("%d ", nums[tll][tlc])
// 		}
// 		for ; tll > lline; tll-- {
// 			fmt.Printf("%d ", nums[tll][tlc])
// 		}
// 	}
// }

// func tree(root *node) int {
// 	if root == nil {
// 		return 0
// 	}
// 	var process func(root *node, h int, l int) int
// 	process = func(root *node, h int, l int) int {
// 		if h == l {
// 			return 1
// 		}
// 		if sumheight(root.r, l+1) == h {
// 			return 1<<(h-l) + process(root.r, h, l+1)
// 		} else {
// 			return 1<<(h-l-1) + process(root.l, h, l+1)
// 		}
// 	}
// 	return process(root, sumheight(root, 1), 1)
// }
// func sumheight(root *node, level int) int {
// 	for root != nil {
// 		root = root.l
// 		level++
// 	}
// 	return level - 1
// }

// func tree(n int) []*node {
// 	var dfs func(start, end int) []*node
// 	dfs = func(start, end int) []*node {
// 		res := make([]*node, 0)
// 		if start > end {
// 			return []*node{nil}
// 		}
// 		var head *node
// 		for i := start; i <= end; i++ {
// 			head = &node{
// 				val: i,
// 			}
// 			l := dfs(start, i-1)
// 			r := dfs(i+1, end)

// 			for _, v := range l {
// 				for _, k := range r {
// 					head.l = v
// 					head.r = k
// 					res = append(res, newTree(head))
// 				}
// 			}
// 		}
// 		return res
// 	}

// 	return dfs(0, n)
// }

// func newTree(root *node) *node {
// 	if root == nil {
// 		return nil
// 	}
// 	head := &node{
// 		val: root.val,
// 	}
// 	head.l = newTree(root.l)
// 	head.r = newTree(root.r)
// 	return head
// }

// func tree(n int) int {
// 	if n < 2 {
// 		return 1
// 	}
// 	f := make([]int, n+1)
// 	f[0] = 1

// 	for i := 1; i < n+1; i++ {
// 		for j := 1; j < i+1; j++ {
// 			f[i] += f[j-1] * f[i-j]
// 		}
// 	}
// 	return f[n]
// }

// func tree(pre []int,mid []int) []int{
// 	if len(pre) == 0{
// 		return nil
// 	}
// 	res := make([]int,len(pre))
// 	index := len(pre) - 1

// 	n := len(pre)

// 	var dfs func(pre,mid []int)
// 	dfs = func(pre,mid []int){
// 		if len(pre) == 0 {
// 			return
// 		}
// 		value := pre[0]
// 		res[index] = value
// 		index--
// 		i:=0
// 		for ;i<len(mid);i++{
// 			if mid[i] == value{
// 				break
// 			}
// 		}
// 		dfs(pre[1+i:],mid[i+1:])
// 		dfs(pre[1:1+i],mid[:i])
// 	}
// 	dfs(pre,mid)
// 	return res
// }

// func tree(pre []int,mid []int) []int{
// 	if len(pre) == 0{
// 		return nil
// 	}
// 	res := make([]int,len(pre))
// 	index := len(pre) - 1
// 	indexmap := make(map[int]int)
// 	n := len(pre)
// 	for i:=0;i<n;i++{
// 		indexmap[mid[i]] = i
// 	}
// 	var dfs func(pl,pr,ml,mr int)
// 	dfs = func(pl,pr,ml,mr int){
// 		if pl > pr {
// 			return
// 		}
// 		value := pre[pl]
// 		midindex := indexmap[value]

// 		res[index] = value
// 		index--

// 		dfs(pl+1+midindex-ml,pr,midindex+1,mr)
// 		dfs(pl+1,pl+midindex,ml,midindex-1)
// 	}
// 	dfs(0,n,0,n)
// 	return res
// }

// type Employ struct {
// 	happy int
// 	subordinates []*Employ
// }
// type variesnum struct{
// 	yes_go int
// 	no_go int
// }
// func tree(root *Employ) int{
// 	if root == nil{
// 		return 0
// 	}
// 	var dfs func(root *Employ) *variesnum
// 	dfs = func(root *Employ) *variesnum{
// 		yes_go := root.happy
// 		no_go := 0

// 		for _,v := range root.subordinates{
// 			value :=  dfs(v)
// 			yes_go += value.no_go
// 			no_go += max(value.no_go,value.yes_go)
// 		}
// 		return &variesnum{yes_go,no_go}
// 	}
// 	res := dfs(root)
// 	return max(res.no_go,res.yes_go)
// }
// type data struct{
// 	maxDistance int
// 	height int
// }
// func FindMaxDistance(root *node) int{
// 	if root == nil{
// 		return 0
// 	}
// 	res := -1
// 	var dfs func(root *node) *data
// 	dfs = func(root *node) int{
// 		if root == nil{
// 			return 0
// 		}
// 		l := dfs(root.l)
// 		r := dfs(root.r)
// 		height := max(l.height,r.height) + 1
// 		maxdis := max(l.height + r.height + 1,max(l.maxDistance,r.maxDistance))
// 		return &data{maxDistance:maxdis,height: height}
// 	}
// 	return dfs(root).maxDistance
// }
// func FindMaxDistance(root *node) int{
// 	if root == nil{
// 		return 0
// 	}
//     maxDistance := 0
// 	var dfs func(root *node)int
// 	dfs = func(root *node) int{
// 		if root == nil{
//             return 0
// 		}
// 		l := dfs(root.l)
// 		r := dfs(root.r)
//         if l + r + 1 > maxDistance{
//             maxDistance = l + r + 1
//         }
// 		ret := max(l,r) + 1
// 		return ret
// 	}
//     dfs(root)
// 	return maxDistance
// }
// func FindMaxDistance(root *node) int{
// 	if root == nil{
// 		return 0
// 	}
// 	res := -1
// 	var dfs func(root *node) int
// 	dfs = func(root *node) int{
// 		if root == nil{
// 			return 0
// 		}
// 		l := dfs(root.l)
// 		r := dfs(root.r)
// 		if l + r + 1 > res{
// 			res = l + r + 1
// 		}
// 		return max(l,r) + 1
// 	}
// 	return dfs(root)
// }

// func FindMaxDistance(root *node,node1 int,node2 int) int{
// 	if root == nil{
// 		return 0
// 	}
// 	node := FindPublicNode(root,node1,node2)
// 	if node.val == node1 {
// 		return find1(node,node1)
// 	}else if node.val == node2{
// 		return find1(node,node2)
// 	}
// 	return find2(node,node1,node2)
// }

// func find2(node *node,node1 int,node2 int) int{
// 	if node == nil{
// 		return 0
// 	}
// 	if node.val == node1 || node.val == node2{
// 		return 1
// 	}
// 	l := find2(node.l,node1,node2)
// 	r := find2(node.r,node1,node2)
// 	if l != 0 && r != 0{
// 		return l + r + 1
// 	}else if l != 0{
// 		return l + 1
// 	}else if r != 0{
// 		return r + 1
// 	}
// 	return 0
// }

// func find1(node *node,node1 int) int{
// 	if node == nil{
// 		return 0
// 	}
// 	if node.val == node1{
// 		return 1
// 	}
// 	l := find1(node.l)
// 	r := find1(node.r)
// 	if l != 0{
// 		return l+1
// 	}else if r != 0{
// 		return r + 1
// 	}
// 	return 0
// }

// func FindPublicNode(root *node,node1 int,node2 int) *node{
// 	if root == nil{
// 		return nil
// 	}
// 	if root.val == node1 || root.val == node2{
// 		return root
// 	}
// 	l := FindIndex(root.l)
// 	r := FindIndex(root.r)
// 	if l != nil && r != nil {
// 		return root
// 	}else if l != nil{
// 		return l
// 	}else {
// 		return r
// 	}
// }

// func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {

// }
// type nodeparen struct{
// 	val int
// 	l *nodeparen
// 	r *nodeparen
// 	parent *nodeparen
// }
// func find(root *nodeparen,target int) *nodeparen{
// 	if root == nil{
// 		return nil
// 	}
// 	if root.val == target{
// 		return root
// 	}
// 	l := find(root.l)
// 	r := find(root.r)
// 	if l != nil{
// 		return l
// 	}
// 	return r
// }
// func tree(root *nodeparen) *nodeparent{
// 	if root.parent == nil{
// 		return nil
// 	}
// 	if root.r != nil{
// 		root = root.r
// 		for root.l != nil{
// 			root = root.l
// 		}
// 		return root
// 	}

// 	node := root.parent
// 	for node !=nil && node.l != root{
// 		node = node.parent
// 		root = root.parent
// 	}
// 	return node
// }

// func tree(nums []int) *node{
// 	if len(nums) == 0{
// 		return nil
// 	}

// 	var dfs func(nums []int) *node
// 	dfs = func(nums []int) *node{
// 		if len(nums) == 0{
// 			return nil
// 		}
// 		midindex := len(nums)/2
// 		root := &node{
// 			val : nums[midindex],
// 		}
// 		root.l = dfs(nums[:midindex])
// 		root.r = dfs(nums[midindex+1:])
// 		return root
// 	}
// 	return dfs(nums)
// }
// func Isseek(root *node) bool{
// 	res := make([]int,0)
// 	var dfs func(root *node)
// 	dfs = func(root *node){
// 		if root == nil{
// 			return nil
// 		}
// 		dfs(root.l)
// 		res = append(res,root.val)
// 		dfs(root.r)
// 	}
// 	dfs(root)
// 	for i:=0;i<len(res)-1 ;i++{
// 		if res[i] >= res[i+1]{
// 			return false
// 		}
// 	}
// 	return true
// }

// func Isall(root *node) bool{
// 	nodes := make([]*node,0)
// 	nodes = append(nodes,root)
// 	ok := false
// 	for len(nodes) > 0{

// 		n := len(nodes)
// 		for i:=0;i<n;i++{
// 			node := nodes[0]
// 			nodes = nodes[1:]
// 			if (ok && ( node.l != nil || node.r != nil)) || (node.l == nil && node.r != nil){
// 				return false
// 			}
// 			if node.l != nil{
// 				nodes = append(nodes,node.l)
// 			}
// 			if node.r != nil{
// 				nodes = apend(nodes,node.r)
// 			}else{
// 				ok = true
// 			}

// 		}
// 		return  true
// 	}
// }
// func Ismin(nums []int,value) bool{
// 	for i:=0;i<len(nums);i++{
// 		if nums[i] <= value{
// 			return fasle
// 		}
// 	}
// 	return true
// }

// func Ismax(nums []int,value) bool{
// 	for i:=0;i<len(nums);i++{
// 		if nums[i] >= value{
// 			return fasle
// 		}
// 	}
// 	return true
// }

// func findmiddle(nums []int,value int) int{
// 	for i:=len(nums)-1;i>=0;i--{
// 		if nums[i] < value{
// 			return i
// 		}
// 	}
// 	return 0
// }
// func tree(nums []int) bool{
// 	if len(nums) == 0{
// 		return true
// 	}
// 	head := nums[len(nums)-1]
// 	nums = nums[:len(nums)-1]
// 	index = findmiddle(nums,head)
// 	if !Ismin(nums[index+1:])||!Ismax(nums[:index+1]){
// 		return false
// 	}
// 	l := tree(nums[:index+1])
// 	r := tree(nums[index+1:])
// 	return l && r
// }
// func tree(root *node) bool{
// 	if root == nil{
// 		return true
// 	}
// 	var dfs func(root *node)(int,bool){
// 		if root == nil{
// 			return 0,true
// 		}
// 		left,lok := dfs(root.l)
// 		right,rok := dfs(root.r)
// 		if !lok || !rok{
// 			return 0,false
// 		}
// 		if left - right > 1 || right - left > 1{
// 			return 0,false
// 		}
// 		return max(left,right) + 1,true
// 	}
// 	_,ok := dfs(root)
// 	return ok
// }

// func tree(t1 *node,t2 *node) bool{
//     if t2 == nil{
//         return true
//     }
// 	var dfs func(t *node) *node //在t1中找到t2头节点相同值的起始节点
// 	dfs = func(t *node) *node{
//         if t == nil{
// 			return nil
// 		}
//         if t.val == t2.val{
// 			return t
// 		}
// 		l := dfs(t.l)
// 		r := dfs(t.r)
// 		if l != nil && l.val == t2.val{
// 			return l
// 		}
// 		return r
// 	}
// 	head := dfs(t1)

// 	var contains func(t1 *node,t2 *node) bool
// 	contains = func(t1 *node,t2 *node) bool{
//         if t2==nil && t1==nil || t2.val == t1.val{
// 			return true
//         }else if (t1 == nil && t2 != nil) || (t1!=nil && t2 == nil) || t2.val != t1.val{
//             return false
//         }

// 		l := contains(t1.l,t2.l)
// 		r := contains(t1.r,t2.r)
// 		return l && r
// 	}
// 	return contains(head,t2)
// }
// func tree(t1 *node,t2 *node) bool{
// 	var dfs func(t1 *node) *node
// 	dfs = func(t1 *node) *node{
// 		if t1 == nil{
// 			return nil
// 		}
// 		if t1 == t2{
// 			return t1
// 		}
// 		l := dfs(t1.l)
// 		r := dfs(t1.r)
// 		if l != nil{
// 			return l
// 		}
// 		return r
// 	}
// 	head := dfs(t1)

// 	var contains func(t1 *node,t2 *node) bool
// 	contains = func(t1 *node,t2 *node) bool{
// 		if t1 != t2 && t2 != nil{
// 			return false
// 		}else if t2 == nil{
// 			return true
// 		}
// 		l := contains(t1.l,t2.l)
// 		r := contains(t1.r,t2.r)
// 		return l || r
// 	}
// 	return contains(head,t2)
// }

// if (e1 == head){
// 	if  (e1 == e2p)
// }

// func FindParent(root *node,n1 int,n2 int) (res []*node){
// 	if root == nil{
// 		return
// 	}
// 	if root.l.val == n1 || root.r.val == n1{
// 		res[0] = root
// 	}
// 	if root.l.val == n2 || root.r.val == n2{
// 		res[1] = root
// 	}
// 	FindIndex(root.l)
// 	FindIndex(root.r)
// }
// func RecoverTree(root *node) *node{
// 	if root == nil{
// 		return nil
// 	}
// 	errs := tree(root)
// 	parents := FindParent(root,errs[0],errs[1])

// 	e1 := parents[0]
// 	e2 := parents[1]
// }
// func tree(root *node) []int{
// 	if root == nil{
// 		return nil
// 	}
// 	indexs := make([]int,0)
// 	res := make([]int,2)
// 	var dfs func(root *node)
// 	dfs = func(root *node){
// 		if root == nil{
// 			return nil
// 		}
// 		dfs(root.l)
// 		indexs = append(indexs, root.Val)
// 		dfs(root.r)
// 	}
// 	dfs(root)
// 	flag := false
// 	for i:=0;i<len(indexs)-1;i++{
// 		if indexs[i] > index[i+1] && !flag{
// 			res[0] = indexs[i]
// 			res[1] = indexs[i+1]
// 			flag = true
// 		}else if indexs[i] > index[i+1]{
// 			res[1] = indexs[i+1]
// 		}
// 	}
// 	return res
// }
// type Recode struct{
// 	l int
// 	r int
// }
// func bstTopoSize2(root *node) int{
// 	if root == nil{
// 		return 0
// 	}
// 	nodemap := make(map[*node]Recode)
// 	return postorder(root,nodemap)
// }

// func postorder(root *node,nodemap map[*node]Recode) int{
// 	if root == nil{
// 		return 0
// 	}
// 	l := postorder(root.l,nodemap)
// 	r := postorder(root.r,nodemap)
// 	modifyMap(root.l,root.val,nodemap,true)
// 	modifyMap(root.r,root.val,nodemap,false)

// 	var lv,rv int
// 	if v,ok := nodemap[root.l];ok{
// 		lv = v.l + v.r + 1
// 	}
// 	if v,ok := nodemap[root.r];ok{
// 		rv = v.l + v.r + 1
// 	}
// 	nodemap[root] = Recode{
// 		l:lv,
// 		r:rv,
// 	}
// 	return max(rv+lv+1,max(l,r))
// }

// func modifyMap(n *node,v int, nodemap map[*node]Recode,s bool) int{
// 	if _,ok := nodemap[n];!ok || n == nil{
// 		return 0
// 	}
// 	r := nodemap[n]
// 	if s && n.val > v || !s && n.val < v{
// 		delete(nodemap,n)
// 		return r.l + r.r + 1
// 	}else{
// 		var minus int
// 		if s{
// 			minus = modifyMap(n.r,v,nodemap,s)
// 			r.r = r.r - minus
// 		}else{
// 			minus = modifyMap(n.l,v,nodemap,s)
// 			r.l = r.l - minus
// 		}
// 		m[n] = r
// 		return minus
// 	}
// }
// type SeekEle struct{
// 	minvalue int
// 	maxvalue int
// 	n *node
// 	cnt int
// }
// type node struct{
// 	val int

// 	l *node
// 	r *node
// }
// func tree(root *node) int{
// 	maxcnt := 0

// 	var ReverseTree func(root *node) *SeekEle
// 	ReverseTree = func(root *node) *SeekEle{
// 		if root == nil{
// 			return &SeekEle{
// 				minvalue: math.MaxInt32,
// 				maxvalue: math.MinInt32,
// 				n: nil,
// 				cnt : 0,
// 			}
// 		}
// 		left := ReverseTree(root.Left)
// 		right := ReverseTree(root.Right)
// 		minvalue := min(root.Val,min(left.minvalue,right.minvalue))
// 		maxvalue := max(root.val,max(left.maxvalue,right.maxvalue))

// 		m := &SeekEle{
// 			minvalue: minvalue,
// 			maxvalue: maxvalue,
// 		}
// 		var tempnode *node
// 		tempcnt := 0
// 		if left.cnt > right.cnt{
// 			tempcnt = left.cnt
// 			tempnode = left.n
// 		}else{
// 			tempcnt = right.cnt
// 			tempnode = right.n
// 		}

// 		if left.n == root.l && right.n == root.r && root.val > left.maxvalue && root.val < right.minvalue{
// 			tempnode = root
// 			tempcnt = left.cnt + right.cnt + 1
// 		}
// 		maxcnt = max(maxcnt,tempcnt)
// 		m.cnt = tempcnt
// 		m.n = tempnode
// 		return m
// 	}
// 	ReverseTree(root)
// 	return maxcnt
// }

// func bstTopoSize1(head *node) int{
// 	if head == nil{
// 		return nil
// 	}

// 	maxvalue := maxTopo(head,head)
// 	maxvalue = max(bstTopoSize1(head.l),maxvalue)
// 	maxvalue = max(bstTopoSize1(head.r),maxvalue)

// 	return max
// }

// func maxTopo(h *node,n *node) int{
// 	if h != nil && n != nil && isBSTNode(h,n,n.val){
// 		return maxTopo(h,n.l) + maxTopo(h,n.r) + 1
// 	}
// 	return 0
// }

// func isBSTNode(h *node,n *node,value int) bool{
// 	if h == nil{
// 		return false
// 	}
// 	if h==n{
// 		return true
// 	}
// 	if h.val > value{
// 		return isBSTNode(h.l,n,value)
// 	}
// 	return isBSTNode(h.r,n,value)
// }

// func makeTree()(*node, int){
//     var n, root, k int
//     fmt.Scanf("%d %d\n", &n, &root)
//     read := bufio.NewReader(os.Stdin)
//     m := make(map[int]*node, n)
//     r := &node{root, nil, nil}
//     m[root]=r
//     for i:=0; i<n; i++{
//         line, _:= read.ReadString('\n')
//         tmp := strings.Split(line[:len(line)-1]," ")
//         v,_:= strconv.Atoi(tmp[0])
//         val, _:= strconv.Atoi(tmp[3])
//         fa := m[v]
//         fa.val = val
//         if tmp[1]!= "0"{
//             v1, _:= strconv.Atoi(tmp[1])
//             n1 := &node{v1, nil, nil}
//             fa.l= n1
//             m[v1]=n1
//         }
//         if tmp[2]!= "0"{
//             v2,_:= strconv.Atoi(tmp[2])
//             n2:= &node{v2, nil,nil}
//             fa.r= n2
//             m[v2]=n2
//         }
//     }
//     line,_ := read.ReadString('\n')
//     k,_ =strconv.Atoi(line[:len(line)-1])

//     return r, k
// }

// func tree(root *node, val int) int {
// 	maxlen := 0
// 	tmap := make(map[int]int)
//     tmap[0] = 0
// 	var computeTreePath func(root *node, presum int, level int) int

// 	computeTreePath = func(root *node, presum int, level int) int {
// 		if root == nil {
// 			return 0
// 		}
// 		cntsum := presum + root.val
// 		if _, ok := tmap[cntsum]; !ok {
// 			tmap[cntsum] = level
// 		}
// 		if k, ok := tmap[cntsum-val]; ok {
// 			maxlen = max(maxlen, level-k)
// 		}

// 		leftlen := computeTreePath(root.l, cntsum, level+1)
// 		rightlen := computeTreePath(root.r, cntsum, level+1)

// 		if tmap[cntsum] == level {
// 			delete(tmap, cntsum)
// 		}
// 		return max(maxlen, max(leftlen, rightlen))
// 	}
// 	return computeTreePath(root, 0, 1)
// }

// func makeTree() (*TreeNode, int) {
// 	var n, root, k int
// 	fmt.Scanf("%d %d\n", &n, &root)
// 	read := bufio.NewReader(os.Stdin)
// 	m := make(map[int]*TreeNode, n)
// 	r := &TreeNode{root, nil, nil}
// 	m[root] = r
// 	for i := 0; i < n; i++ {
// 		line, _ := read.ReadString('\n')
// 		tmp := strings.Split(line[:len(line)-1], " ")
// 		v, _ := strconv.Atoi(tmp[0])
// 		val, _ := strconv.Atoi(tmp[3])
// 		fa := m[v]
// 		fa.Val = val
// 		if tmp[1] != "0" {
// 			v1, _ := strconv.Atoi(tmp[1])
// 			n1 := &TreeNode{v1, nil, nil}
// 			fa.Left = n1
// 			m[v1] = n1
// 		}
// 		if tmp[2] != "0" {
// 			v2, _ := strconv.Atoi(tmp[2])
// 			n2 := &TreeNode{v2, nil, nil}
// 			fa.Right = n2
// 			m[v2] = n2
// 		}
// 	}
// 	line, _ := read.ReadString('\n')
// 	k, _ = strconv.Atoi(line[:len(line)-1])

// 	return r, k
// }
// func tree(root *TreeNode, val int) int {
// 	maxlen := 0
// 	tmap := make(map[int]int)

// 	var computeTreePath func(root *TreeNode, presum int, level int) int

// 	computeTreePath = func(root *TreeNode, presum int, level int) int {
// 		if root == nil {
// 			return 0
// 		}
// 		cntsum := presum + root.Val
// 		if _, ok := tmap[cntsum]; !ok {
// 			tmap[cntsum] = level
// 		}
// 		if k, ok := tmap[cntsum-val]; ok {
// 			maxlen = max(maxlen, level-k+1)
// 		}

// 		leftlen := computeTreePath(root.Left, cntsum, level+1)
// 		rightlen := computeTreePath(root.Right, cntsum, level+1)

// 		if tmap[cntsum] == level {
// 			delete(tmap, cntsum)
// 		}
// 		return max(maxlen, max(leftlen, rightlen))
// 	}
// 	return computeTreePath(root, 0, 1)
// }

// func kIncreasing(arr []int, k int) int {
// 	if len(arr) == 0 {
// 		return 0
// 	}
// 	res := 0
// 	n := len(arr)
// 	for i := 0; i < k; i++ {
// 		karr := make([]int, 0)
// 		for j := i; j < n; j += k {
// 			karr = append(karr, arr[j])
// 		}
// 		fmt.Println(karr)
// 		res += len(karr) - f(karr)
// 	}
// 	return res
// }

// func f(inputs []int) int {
// 	if len(inputs) == 0 {
// 		return 0
// 	}

// 	ends := make([]int, len(inputs))
// 	maxvalue := 1
// 	right := 0
// 	ends[0] = inputs[0]

// 	for i := 1; i < len(inputs); i++ {
// 		l, r := 0, right
// 		for l <= r {
// 			m := (l + r) / 2
// 			if ends[m] <= inputs[i] {
// 				l = m + 1
// 			} else {
// 				r = m - 1
// 			}
// 		}
// 		right = max(right, l)
// 		ends[l] = inputs[i]
// 		if maxvalue < l+1 {
// 			maxvalue = l + 1
// 		}
// 	}

// 	return maxvalue
// }

// func kIncreasing(arr []int, k int) int {
// 	if len(arr) == 0 {
// 		return 0
// 	}
// 	res := 0

// 	for i := 0; i < len(arr); i++ {
// 		if i+k < len(arr) && arr[i+k] < arr[i] {
// 			if i+2*k < len(arr) && arr[i+2*k] < arr[i+k] {
// 				arr[i] = arr[i+k]
// 			} else {
// 				arr[i+k] = arr[i]
// 			}
// 			res++
// 		}
// 		if i+k >= len(arr) {
// 			break
// 		}
// 	}
// 	return res
// }

// func getDescentPeriods(prices []int) int64 {
// 	if len(prices) == 0 {
// 		return 0
// 	}
// 	f := make([]int, len(prices))
// 	f[0] = 1
// 	res := int64(f[0])
// 	for i := 1; i < len(prices); i++ {
// 		f[i] = 1
// 		if prices[i] == prices[i-1]-1 {
// 			f[i] += f[i-1]
// 		}
// 		res += int64(f[i])
// 	}
// 	return int64(res)
// }
// func addSpaces(s string, spaces []int) string {
// 	if len(spaces) == 0 {
// 		return s
// 	}
// 	n := len(s)
// 	m := len(spaces)
// 	index := m - 1
// 	total := n + m - 1
// 	out := make([]byte, m+n)

// 	for i := n - 1; i >= 0; i-- {
// 		out[total] = s[i]
// 		total--
// 		if index >= 0 && i == spaces[index] {
// 			out[total] = ' '
// 			total--
// 			index--
// 		}
// 	}
// 	return string(out)
// }

// func firstPalindrome(words []string) string {
// 	if len(words) == 0 {
// 		return ""
// 	}
// 	n := len(words)

// 	for i := 0; i < n; i++ {
// 		k := true
// 		for j := 0; j < len(words[i])/2; j++ {
// 			if words[i][j] != words[i][len(words[i])-j-1] {
// 				k = false
// 				break
// 			}
// 		}
// 		if k {
// 			return words[i]
// 		}
// 	}
// 	return ""
// }
// func addSpaces(s string, spaces []int) string {
// 	if len(spaces) == 0 {
// 		return s
// 	}
// 	res := s[:spaces[0]]
// 	pre := spaces[0]
// 	for i := 1; i < len(spaces); i++ {
// 		res += s[pre:spaces[i]] + " "
// 		pre = spaces[i]
// 	}
// 	res += s[pre:]
// 	return res
// }

// func tree(root *TreeNode) string {
// 	if root == nil {
// 		return "#!"
// 	}
// 	nodes := make([]*TreeNode, 0)
// 	res := ""
// 	nodes = append(nodes, root)
// 	for len(nodes) != 0 {
// 		n := len(nodes)
// 		for i := 0; i < n; i++ {
// 			node := nodes[0]
// 			nodes = nodes[1:]
// 			if node == nil {
// 				res += "#!"
// 				continue
// 			} else {
// 				res += string(node.Val) + "!"
// 			}
// 			nodes = append(nodes, node.Left)
// 			nodes = append(nodes, node.Right)
// 		}
// 	}
// 	return res
// }

// func reverseTree(values string) *TreeNode {
// 	if values[0] == '#' {
// 		return nil
// 	}
// 	numbers := strings.Split(values, "!")
// 	nodes := make([]*TreeNode, 0)
// 	index := 0
// 	root := getNumber(numbers[index])
// 	nodes = append(nodes, root)
// 	index++
// 	for len(nodes) != 0 {
// 		h := len(nodes)
// 		for i := 0; i < h; i++ {
// 			node := nodes[0]
// 			nodes = nodes[1:]
// 			node.Left = getNumber(numbers[index])
// 			index++
// 			node.Right = getNumber(numbers[index])
// 			index++
// 			if node.Left != nil {
// 				nodes = append(nodes, node.Left)
// 			}
// 			if node.Right != nil {
// 				nodes = append(nodes, node.Right)
// 			}
// 		}
// 	}
// 	return root
// }
// func getNumber(value string) *TreeNode {
// 	if value == "#" {
// 		return nil
// 	} else {
// 		n, _ := strconv.Atoi(value)
// 		return &TreeNode{
// 			Val: n,
// 		}
// 	}
// }

// func tree(root *TreeNode) string {
// 	if root == nil {
// 		return "#!"
// 	}
// 	res := string(root.Val) + "!"
// 	res += tree(root.Left)
// 	res += tree(root.Right)
// 	return res
// }

// func reverseTree(root string) *TreeNode {
// 	values := strings.Split(root, "!")

// 	func tree(values []string) *TreeNode
// 	tree = func(values []string) *TreeNode{
// 		k := values[0]
// 		values = values[1:]
// 		if k == "#"{
// 			return nil
// 		}
// 		root := &TreeNode{
// 			Val: k,
// 		}
// 		root.Left  = tree(values)
// 		root.Right = tree(values)
// 		return root
// 	}
// 	return root(values)
// }

// func minDepth(root *TreeNode) int {
// 	if root == nil {
// 		return 0
// 	}
// 	left := minDepth(root.Left)
// 	right := minDepth(root.Right)
// 	if left == 0 && right == 0 {
// 		return 1
// 	} else if left != 0 && right != 0 {
// 		return min(left, right) + 1
// 	} else if left != 0 {
// 		return left + 1
// 	} else {
// 		return right + 1
// 	}
// }

// type recode struct {
// 	value int
// 	time  int
// }

// func pre(root *TreeNode) {
// 	if root == nil {
// 		return
// 	}
// 	fmt.Println(root.Val)
// 	pre(root.Left)
// 	pre(root.Right)
// }
// func pre(root *TreeNode) {
// 	if root == nil {
// 		return
// 	}
// 	result := make([]int, 0)
// 	stack := make([]*TreeNode, 0)
// 	for root != nil || len(stack) != 0 {
// 		for root != nil {
// 			result = append(result, root.Val)
// 			stack = append(stack, root)
// 			root = root.Left
// 		}
// 		node := stack[len(stack)-1]
// 		stack = stack[:len(stack)-1]
// 		root = node.Right
// 	}
// }

// func mid(root *TreeNode) {
// 	if root == nil {
// 		return
// 	}
// 	mid(root.Left)
// 	fmt.Println(root.Val)
// 	mid(root.Right)
// }

// func mid(root *TreeNode) {
// 	if root == nil {
// 		return
// 	}
// 	result := make([]int, 0)
// 	stack := make([]*TreeNode, 0)

// 	for root != nil || len(stack) != 0 {
// 		for root != nil {
// 			stack = append(stack, root)
// 			root = root.Left
// 		}
// 		node := stack[len(stack)-1]
// 		stack = stack[:len(stack)-1]
// 		result = append(result, node.Val)
// 		root = node.Right
// 	}
// }
// func last(root *TreeNode) {
// 	if root == nil {
// 		return
// 	}

// 	last(root.Left)
// 	last(root.Right)
// 	fmt.Println(root.Val)
// }

// func last(root *TreeNode) {
// 	if root == nil {
// 		return
// 	}
// 	result := make([]int, 0)
// 	stack := make([]*TreeNode, 0)
// 	var pre *TreeNode
// 	for root != nil || len(stack) > 0 {
// 		for root != nil {
// 			stack = append(stack, root)
// 			root = root.Left
// 		}
// 		node := stack[len(stack)-1]

// 		if node.Right == nil || node.Right == pre {
// 			stack = stack[:len(stack)-1]
// 			result = append(result, node.Val)
// 			pre = node
// 		} else {
// 			root = node.Right
// 		}
// 	}
// }

// func f(nums []int) int {
// 	if len(nums) == 0 || len(nums) < 2 {
// 		return 0
// 	}

// 	n := len(nums)
// 	maxIndex := 0
// 	res := 0
// 	stack := make([]recode, 0)
// 	for i := 1; i < n; i++ {
// 		if nums[maxIndex] < nums[i] {
// 			maxIndex = i
// 		}
// 	}
// 	stack = append(stack, recode{value: nums[maxIndex], time: 1})
// 	index := nextIndex(maxIndex, n)

// 	for index != maxIndex {
// 		for nums[index] > nums[stack[len(stack)-1].value] {
// 			k := stack[len(stack)-1].time
// 			res += 2*k + getInternalSum(k)
// 			stack = stack[:len(stack)-1]
// 		}
// 		if nums[index] == nums[stack[len(stack)-1].value] {
// 			stack[len(stack)-1].time++
// 		} else {
// 			stack = append(stack, recode{value: nums[index], time: 1})
// 		}
// 		index = nextIndex(index, n)
// 	}
// 	for len(stack) > 2 {
// 		k := stack[len(stack)-1].time
// 		res += getInternalSum(k) + 2*k
// 		stack = stack[:len(stack)-1]
// 	}
// 	k := stack[0].time
// 	if k > 1 {
// 		res += 2*stack[1].time + getInternalSum(stack[1].time)
// 	} else {
// 		res += stack[1].time + getInternalSum(stack[1].time)
// 	}
// 	res += getInternalSum(stack[0].time)
// 	return res
// }

// func nextIndex(i int, size int) int {
// 	if i < size-1 {
// 		return i + 1
// 	}
// 	return 0
// }
// func getInternalSum(k int) int {
// 	if k == 1 {
// 		return 0
// 	}
// 	return k * (k - 1) / 2
// }

// func f(nums []int, target int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	res := 0
// 	minList := make([]int, 0)
// 	maxList := make([]int, 0)
// 	n := len(nums)
// 	i, j := 0, 0
// 	for i < n {
// 		for j < n { //表示当前i下j最多可以右扩到哪里
// 			if len(minList) == 0 || minList[len(minList)-1] != j {
// 				for len(minList) != 0 && nums[minList[len(minList)-1]] >= nums[j] {
// 					minList = minList[:len(minList)-1]
// 				}
// 				for len(maxList) != 0 && nums[maxList[len(maxList)-1]] <= nums[j] {
// 					maxList = maxList[:len(maxList)-1]
// 				}
// 				minList = append(minList, j)
// 				maxList = append(maxList, j)
// 			}

// 			if j-i == target {
// 				break
// 			}
// 			j++
// 		}
// 		res = max(res, maxList[0]-minList[0])
// 		if minList[0] == i {
// 			minList = minList[1:]
// 		}
// 		if maxList[0] == i {
// 			maxList = maxList[1:]
// 		}
// 		i++
// 	}
// 	return res
// }

// func maxOne(inputs [][]int) int {
// 	if len(inputs) == 0 || len(inputs[0]) == 0 {
// 		return 0
// 	}

// 	res := 0
// 	dp := make([]int, len(inputs[0]))
// 	for i := 0; i < len(inputs); i++ {
// 		for j := 0; j < len(inputs[0]); j++ {
// 			if inputs[i][j] != 0 {
// 				dp[j] += 1
// 			} else {
// 				dp[j] = 0
// 			}
// 		}

// 		nums := f(dp)
// 		for j := 0; j < len(nums); j++ {
// 			n := dp[j] * (nums[j][1] - nums[j][0] - 1)
// 			if res < n {
// 				res = n
// 			}
// 		}
// 	}
// 	return res
//  }

// func f(nums []int) [][]int {
// 	if len(nums) == 0 {
// 		return nil
// 	}
// 	n := len(nums)
// 	stack := make([]int, 0)
// 	res := make([][]int, n)
// 	for i := 0; i < len(res); i++ {
// 		res[i] = make([]int, 2)
// 	}
// 	for i := 0; i < n; i++ {
// 		for len(stack) != 0 && nums[stack[len(stack)-1]] > nums[i] {
// 			k := stack[len(stack)-1]
// 			stack = stack[:len(stack)-1]
// 			h := len(stack)
// 			for h != 0 && nums[stack[h-1]] == nums[k] {
// 				h--
// 			}
// 			if h != 0 {
// 				res[k][0] = stack[h-1]
// 			} else {
// 				res[k][0] = -1
// 			}
// 			res[k][1] = i
// 		}
// 		stack = append(stack, i)
// 	}
// 	for len(stack) != 0 {
// 		k := stack[len(stack)-1]
// 		stack = stack[:len(stack)-1]
// 		h := len(stack)
// 		for h != 0 && nums[stack[h-1]] == nums[k] {
// 			h--
// 		}
// 		if h != 0 {
// 			res[k][0] = stack[h-1]
// 		} else {
// 			res[k][0] = -1
// 		}
// 		res[k][1] = -1
// 	}
// 	return res
// }

// func f(nums []int) [][]int {
// 	if len(nums) == 0 {
// 		return nil
// 	}
// 	n := len(nums)
// 	res := make([][]int, n)
// 	for i := 0; i < n; i++ {
// 		res[i] = make([]int, 2)
// 	}
// 	minstack := make([]int, 0)

// 	for i := 0; i < n; i++ {
// 		if len(minstack) == 0 || nums[minstack[0]] > nums[i] {
// 			res[i][0] = -1
// 			minstack = minstack[:0]
// 			minstack = append(minstack, i)
// 			continue
// 		} else {
// 			for j := len(minstack) - 1; j >= 0; j-- {
// 				if nums[minstack[j]] < nums[i] {
// 					res[i][0] = minstack[j]
// 					break
// 				}
// 				minstack = minstack[:j]
// 			}
// 			minstack = append(minstack, i)
// 		}

// 	}

// 	minstack = minstack[:0]

// 	for i := n - 1; i >= 0; i-- {
// 		if len(minstack) == 0 || nums[minstack[0]] > nums[i] {
// 			res[i][1] = len(nums)
// 			minstack = minstack[:0]
// 			minstack = append(minstack, i)
// 			continue
// 		}
// 		for j := len(minstack) - 1; j >= 0; j-- {
// 			if nums[minstack[j]] < nums[i] {
// 				res[i][1] = minstack[j]
// 				break
// 			}
// 			minstack = minstack[:j]
// 		}
// 		minstack = append(minstack, i)
// 	}

// 	return res
// }

// func f(inputs []int, w int) []int {
// 	if len(inputs) == 0 {
// 		return nil
// 	}
// 	stack := make([]int, 0)
// 	res := make([]int, 0)
// 	for i := 0; i < len(inputs); i++ {
// 		for len(stack) != 0 && inputs[stack[len(stack)-1]] <= inputs[i] {
// 			stack = stack[:len(stack)-1]
// 		}
// 		stack = append(stack, i)
// 		if stack[0] == i-w {
// 			stack = stack[1:]
// 		}
// 		res = append(res, inputs[stack[0]])
// 		fmt.Println(res, stack)
// 	}
// 	return res[w-1:]
// }

// func f(inputs []int) {
// 	stack := make([]int, 0)
// 	for len(inputs) != 0 {
// 		value := inputs[len(inputs)-1]
// 		inputs = inputs[:len(inputs)-1]
// 		for len(stack) != 0 && stack[len(stack)-1] > value {
// 			inputs = append(inputs, stack[len(stack)-1])
// 			stack = stack[:len(stack)-1]
// 		}
// 		stack = append(stack, value)
// 	}
// 	for i:=len(stack)
// 	fmt.Println(stack)
// }

//   var sc = bufio.NewScanner(os.Stdin)
//   func readLine() string {
// 	  sc.Scan()
// 	  return sc.Text()
//   }

//   type TwoListstack struct {
// 	  stack    []int
//   }

//   func ContructTwoListstack() *TwoListstack {
// 	  return &getMinstack{
// 		  stack:    make([]int, 0),
// 	  }
//   }
//   func (t *TwoListstack) Add(value int) {
// 	  t.stack = append(t.stack, value)
//   }
//   func (t *TwoListstack) Poll() {
// 	  t.stack = t.stack[1:]
//   }
//   func (t *TwoListstack) Peek() int {
// 	  return t.stack[0]
//   }
// func main() {

// 	fmt.Println(totalNQueens(10))
// }

// func f(strs []string) {
// 	gm := ContructGetMinstack()
// 	for _, v := range strs {
// 		nv := strings.Split(v, " ")
// 		switch nv[0] {
// 		case "push":
// 			value, _ := strconv.Atoi(nv[1])
// 			gm.push(value)
// 		case "pop":
// 			gm.pop()
// 		case "getMin":
// 			fmt.Println(gm.getMin())
// 		}
// 	}
// }

// type getMinstack struct {
// 	stack    []int
// 	minstack []int
// }

// func ContructGetMinstack() *getMinstack {
// 	return &getMinstack{
// 		stack:    make([]int, 0),
// 		minstack: make([]int, 0),
// 	}
// }
// func (this *getMinstack) push(value int) {
// 	this.stack = append(this.stack, value)
// 	if this.minstack[len(this.minstack)-1] > value {
// 		this.minstack = append(this.minstack, value)
// 	} else {
// 		this.minstack = append(this.minstack, this.minstack[len(this.minstack)-1])
// 	}
// }

// func (this *getMinstack) pop() {
// 	if len(this.stack) != 0 {
// 		this.stack = this.stack[:len(this.stack)-1]
// 		this.minstack = this.minstack[:len(this.minstack)-1]
// 	}

// }

// func (this *getMinstack) getMin() int {
// 	return this.minstack[len(this.minstack)-1]
// }

// func totalNQueens(n int) int {
// 	if n < 1 {
// 		return 0
// 	}
// 	upperLim := (1 << n) - 1
// 	var process func(upperLim int, col int, left int, right int) int
// 	process = func(upperLim int, col int, left int, right int) int {
// 		if upperLim == col {
// 			return 1
// 		}
// 		pos := 0
// 		mostRight := 0
// 		res := 0
// 		pos = upperLim & (^(col | left | right))
// 		for pos != 0 {
// 			mostRight = pos & (^pos + 1)
// 			pos = pos - mostRight
// 			res += process(upperLim, col|mostRight, (left|mostRight)<<1, (right|mostRight)>>1)
// 		}
// 		return res
// 	}
// 	return process(upperLim, 0, 0, 0)

// }

// func totalNQueens(n int) (ans int) {
// 	if n < 1 {
// 		return 0
// 	}
// 	upperLim := (1 << n) - 1 //1表示当前行可以用，这个是固定
// 	var process func(upperLim int, colLim int, leftDiaLim int, rightDiaLim int) int
// 	process = func(upperLim int, colLim int, leftDiaLim int, rightDiaLim int) int {
// 		if colLim == upperLim { //此时表示已经放置到最后一列了
// 			return 1
// 		}

// 		pos := 0                                                //表示当前可以选择的位置
// 		mostRightOne := 0                                       //当前可以选择的位置中最后的位置
// 		pos = upperLim & (^(colLim | leftDiaLim | rightDiaLim)) //去除掉不可选的位置
// 		res := 0
// 		for pos != 0 {
// 			mostRightOne = pos & (^pos + 1) //去除最右边可以用的位置，遍历每一行可以放置的不同位置
// 			pos = pos - mostRightOne
// 			ans += process(upperLim, colLim|mostRightOne, (leftDiaLim|mostRightOne)<<1, (rightDiaLim|mostRightOne)>>1)
// 		}
// 		return res
// 	}
// 	process(upperLim, 0, 0, 0)
// 	return
// }

// func f(inputs []int) int {
// 	if len(inputs) == 0 {
// 		return 0
// 	}
// 	sort.Ints(inputs)
// 	now := 1
// 	res := 1
// 	for i := 1; i < len(inputs); i++ {
// 		if inputs[i] == inputs[i-1]+1 {
// 			now = now + 1
// 			if now > res {
// 				res = now
// 			}
// 		} else {
// 			now = 1
// 		}
// 	}
// 	return res
// }

// func f(inputs []int) int {
// 	if len(inputs) == 0 || len(inputs) == 1 {
// 		return 0
// 	}
// 	limit := inputs[0]
// 	nowvalue := inputs[0]
// 	res := 1
// 	n := len(inputs)
// 	i := 1
// 	for limit < n-1 && i < len(inputs) {
// 		fmt.Println(limit, nowvalue)
// 		if i == limit {
// 			limit = nowvalue
// 			res++
// 		}
// 		if i+inputs[i] > nowvalue {
// 			nowvalue = i + inputs[i]
// 		}
// 		i++
// 	}
// 	return res
// }

// func maxTotalFruits(fruits [][]int, startPos int, k int) int {
// 	if len(fruits) == 0 || len(fruits[0]) == 0 {
// 		return 0
// 	}
// 	kmap := make(map[int]int)
// 	for i := 0; i < len(fruits); i++ {
// 		kmap[fruits[i][0]] = fruits[i][1]
// 	}
// 	dp := make([][]int, fruits[len(fruits)-1][0])
// 	for i := 0; i < len(dp); i++ {
// 		dp[i] = make([]int, k+1)
// 	}
// 	for i := 1; i < len(dp); i++ {
// 		dp[fruits[i][0]][0] = fruits[i][1]
// 	}
// 	for i := 1; i <= k+1; i++ {
// 		dp[fruits[i][0]][i] = kmap[fruits[i][0]-1]
// 	}
// 	for i := fruits[0][0]; i < len(dp); i++ {

// 	}
// }

// func minimumRefill(plants []int, capacityA int, capacityB int) int {
// 	if len(plants) == 0 {
// 		return 0
// 	}
// 	res := 0
// 	left, right := 0, len(plants)-1
// 	nowA, nowB := capacityA, capacityB
// 	for left <= right {
// 		fmt.Println(nowA, nowB)
// 		if left == right {
// 			if nowA >= nowB {
// 				if nowA >= plants[left] {
// 					return res
// 				} else {
// 					return res + 1
// 				}
// 			} else {
// 				if nowB >= plants[right] {
// 					return res
// 				} else {
// 					return res + 1
// 				}
// 			}
// 		}
// 		if nowA >= plants[left] {
// 			nowA -= plants[left]
// 		} else {
// 			nowA = capacityA
// 			nowA -= plants[left]
// 			res++
// 		}
// 		if nowB >= plants[right] {
// 			nowB -= plants[right]
// 		} else {
// 			nowB = capacityB
// 			nowB -= plants[right]
// 			res++
// 		}
// 		left++
// 		right--
// 	}
// 	return res
// }

// func subArrayRanges(nums []int) int64 {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	var res int64
// 	mindp := make([][]int64, len(nums))
// 	maxdp := make([][]int64, len(nums))
// 	for i := 0; i < len(nums); i++ {
// 		mindp[i] = make([]int64, len(nums))
// 		maxdp[i] = make([]int64, len(nums))
// 	}
// 	for i := 0; i < len(nums); i++ {
// 		mindp[i][i] = int64(nums[i])
// 		maxdp[i][i] = int64(nums[i])
// 		for j := i + 1; j < len(nums); j++ {
// 			mindp[i][j] = min(mindp[i][j-1], int64(nums[j]))
// 			maxdp[i][j] = max(maxdp[i][j-1], int64(nums[j]))
// 		}
// 	}
// 	for i := 0; i < len(nums); i++ {
// 		for j := i + 1; j < len(nums); j++ {
// 			res += maxdp[i][j] - mindp[i][j]
// 		}
// 	}
// 	return res
// }

// func countPoints(rings string) int {
// 	if rings == "" || len(rings)%2 != 0 {
// 		return 0
// 	}
// 	res := 0
// 	ringsmap := make(map[string]map[string]bool)
// 	for i := 1; i < len(rings); i += 2 {
// 		if _, ok := ringsmap[string(rings[i])]; !ok {
// 			ringsmap[string(rings[i])] = make(map[string]bool)
// 		}
// 		ringsmap[string(rings[i])][string(rings[i-1])] = true
// 	}
// 	fmt.Println(ringsmap)
// 	for _, v := range ringsmap {
// 		if len(v) == 3 {
// 			res++
// 		}
// 	}
// 	return res
// }

// func goodDaysToRobBank(security []int, time int) []int {
// 	if len(security) == 0 {
// 		return nil
// 	}
// 	lstack := make([]int,time)
// 	rstack := make([]int,time)

// 	for i:=0;i<len(security);i++{

// 		if len(lstack) == 0 || lstack[len(lstack)-1] >=security[i]{
// 			lstack = append(lstack, security[i])
// 			continue
// 		}else{
// 			lstack = lstack[:0]
// 			continue
// 		}
// 		if len(rstack) == 0 || rstack[len(lstack)-1] <= security[i]{
// 			rstack = append(rstack,security[i])
// 			continue
// 		}else{
// 			lstack = lstack[:0]
// 			lstack = append(lstack,rstack[len(lstack)-1])
// 			lstack = append(lstack,security[i])
// 			rstack = rstack[:0]
// 		}
// 	}
// }

// func goodDaysToRobBank(security []int, time int) []int {
// 	if len(security) == 0 || len(security) < 2*time+1 {
// 		return nil
// 	}
// 	res := make([]int, 0)
// 	left, right, i := 0, 0, 0
// 	for i < len(security) {
// 		if left == time {
// 		} else if i+1 < len(security) && security[right] > security[i+1] {
// 			left++
// 		} else {
// 			left = 0
// 		}
// 		if left == time && i+1 < len(security) && security[i] > security[i+1] {
// 			right++
// 		} else {
// 			left = 1
// 		}
// 	}
//}

// func goodDaysToRobBank(security []int, time int) []int {
// 	if len(security) == 0 || len(security) < 2*time+1 {
// 		return nil
// 	}
// 	res := make([]int, 0)
// 	for i := time; i < len(security)-time; i++ {
// 		k := false
// 		index1, index2 := i, i+1
// 		for j := i - time; j < i; j++ {
// 			if security[j] < security[j+1] || security[index1] > security[index2] {
// 				k = true
// 				break
// 			}
// 			index1++
// 			index2++
// 		}
// 		if k {
// 			continue
// 		}
// 		res = append(res, i)
// 		i += time
// 	}
// 	return res
// }

// public int[] largestSubarray(int[] nums, int k) {
// 	int[] res = new int[k];
// 	int rec = 0;
// 	int max = nums[0];
// 	for(int i = 0;i+k-1<nums.length;++i){
// 	   if(nums[i] > max){
// 		   max = nums[i];
// 		   rec = i;
// 	   }
// 	}
// 	for(int j = rec;j < rec + k;++j){
// 		res[j-rec] = nums[j];
// 	}

// 	return res;
// }

// func maxSubsequence(nums []int, k int) []int {
// 	res := make([]int,k)
// 	maxvalue := 0
// 	for i:=0;i<k;i++{
// 		res[i] = nums[i]
// 		maxvalue += nums[i]
// 	}
// 	for i:=k;i<len(nums);i++{
// 		for j:=0;j<len(res);j++{

// 		}
// 	}
// }

// func f(inputs []int) int {
// 	if len(inputs) == 0 {
// 		return 0
// 	}
// 	n := len(inputs)
// 	f := make([][]int, n)
// 	l := make([][]int, n)
// 	for i := 0; i < n; i++ {
// 		f[i] = make([]int, n)
// 		l[i] = make([]int, n)
// 	}
// 	for i := n - 1; i >= 0; i-- {
// 		for j := i + 1; j < n; j++ {
// 			f[i][j] = max(inputs[i]+l[i+1][j], inputs[j]+l[i][j-1])
// 			l[i][j] = min(f[i+1][j], f[i][j-1])
// 		}
// 	}
// 	return max(f[0][n-1], l[0][n-1])
// }

// func f(str string, des bool) int {
// 	if str == "" {
// 		return 0
// 	}
// 	if len(str)&1 == 0 {
// 		return 0
// 	}
// 	for i := 0; i < len(str); i += 2 {
// 		if str[i] != '1' && str[i] != '0' {
// 			return 0
// 		}
// 	}
// 	for i := 1; i < len(str); i += 2 {
// 		if str[i] != '^' && str[i] != '|' && str[i] != '&' {
// 			return 0
// 		}
// 	}
// 	t := make([][]int, len(str))
// 	f := make([][]int, len(str))
// 	for i := 0; i < len(str); i++ {
// 		t[i] = make([]int, len(str))
// 		f[i] = make([]int, len(str))
// 	}
// 	if str[0] == '0' {
// 		f[0][0] = 1
// 	} else {
// 		t[0][0] = 1
// 	}
// 	for i := 2; i < len(str); i += 2 {
// 		if str[i] == '0' {
// 			f[i][i] = 1
// 		} else {
// 			t[i][i] = 1
// 		}
// 		for j := i - 2; j >= 0; j -= 2 {
// 			for k := j; k < i; k += 2 {
// 				if str[k+1] == '&' {
// 					t[j][i] += (t[j][k] * t[k+2][i])
// 					f[j][i] += ((f[j][k]+t[j][k])*f[k+2][i] + f[j][k]*t[k+2][i])
// 				} else if str[k+1] == '|' {
// 					t[j][i] += ((f[j][k]+t[j][k])*t[k+2][i] + t[j][k]*f[k+2][i])
// 					f[j][i] += (f[j][k] * f[k+2][i])
// 				} else {
// 					t[j][i] += (f[j][k]*t[k+2][i] + t[j][k]*f[k+2][i])
// 					f[j][i] += (f[j][k]*f[k+2][i] + t[j][k]*t[k+2][i])
// 				}

// 			}
// 			t[i][j] = t[i][j] % (1e9 + 7)
// 			f[i][j] = f[i][j] % (1e9 + 7)
// 		}
// 	}
// 	if des {
// 		return (t[0][len(str)-1])
// 	}
// 	return (f[0][len(str)-1])
// }

// func f(s1 string) int {
// 	if len(s1) == 0 || s1[0] == '0' {
// 		return 0
// 	}
// 	pre := 1
// 	now := 1
// 	for i := 2; i <= len(s1); i++ {
// 		n := (s1[i-2]-'0')*10 + (s1[i-1] - '0')
// 		if (n > 30 && s1[i-1] == '0') || n == 0 {
// 			return 0
// 		}
// 		if n > 26 || n < 10 {
// 			pre = now
// 		} else {
// 			num := now
// 			now = (now + pre) % (1e9 + 7)
// 			pre = num
// 		}
// 	}
// 	return now
// }

// func f(inputs [][]int) int {
// 	dp := make([]int, len(inputs[0]))
// 	if inputs[len(inputs)-1][len(inputs[0])-1] <= 0{
// 		dp[len(inputs[0])-1] = -1*inputs[len(inputs)-1][len(inputs[0])-1] + 1
// 	} else {
// 		dp[len(inputs[0])-1] = 1
// 	}
// 	for i := len(inputs[0]) - 2; i >= 0; i-- {
// 		dp[i] = dp[i+1] - inputs[len(inputs)-1][i]
// 		if dp[i] <= 0 {
// 			dp[i] = 1
// 		}
// 	}
// 	for i := len(inputs) - 2; i >= 0; i-- {
// 		dp[len(inputs[0])-1] = dp[len(inputs[0])-1] - inputs[i][len(inputs[0])-1]
// 		if dp[len(inputs[0])-1] <= 0 {
// 			dp[len(inputs[0])-1] = 1
// 		}
// 		for j := len(inputs[0]) - 2; j >= 0; j-- {
// 			dp[j] = min(dp[j]-inputs[i][j], dp[j+1]-inputs[i][j])
// 			if dp[j] <= 0 {
// 				dp[j] = 1
// 			}
// 		}
// 	}
// 	return dp[0]
// }

// func f(s1, s2, aim string) bool {
// 	if len(s1)+len(s2) != len(aim) {
// 		return false
// 	}
// 	dp := make([]bool, len(s2)+1)
// 	dp[0] = true
// 	for i := 1; i < len(dp); i++ {
// 		if dp[i-1] && aim[i-1] == s2[i-1] {
// 			dp[i] = true
// 		}
// 	}
// 	for i := 1; i <= len(s1); i++ {
// 		if dp[0] && aim[i-1] == s1[i-1] {
// 			dp[0] = true
// 		} else {
// 			dp[0] = false
// 		}
// 		for j := 1; j <= len(s2); j++ {
// 			if dp[j] && aim[i+j-1] == s1[i-1] || dp[j-1] && aim[i+j-1] == s2[j-1] {
// 				dp[j] = true
// 			} else {
// 				dp[j] = false
// 			}
// 		}
// 	}
// 	return dp[len(s2)]
// }

// func f(s1, s2 string, ic, dc, rc int) int {
// 	if len(s1) == 0 || len(s2) == 0 {
// 		return 0
// 	}
// 	dp := make([]int, len(s2)+1)

// 	for i := 1; i <= len(s2); i++ {
// 		dp[i] = dp[i-1] + dc
// 	}
// 	pre := 0
// 	for i := 1; i <= len(s1); i++ {
// 		pre = dp[0]
// 		dp[0] = i * dc
// 		for j := 1; j <= len(s2); j++ {
// 			temppre := dp[j]
// 			dp[j] = math.MaxInt32
// 			if s1[i-1] == s2[j-1] {
// 				dp[j] = pre
// 			}
// 			num := min(dp[j-1]+ic, temppre+dc)
// 			dp[j] = min(dp[j], min(num, pre+rc))
// 			pre = temppre
// 		}
// 	}
// 	return dp[len(s2)]
// }

// func f(inputs []int) int {
// 	if len(inputs) == 0 {
// 		return 0
// 	}
// 	dp := make([]int, len(inputs)+1)
// 	orMap := make(map[int]int)
// 	res := 0
// 	orMap[0] = 0
// 	for i := 1; i <= len(inputs); i++ {
// 		res ^= inputs[i-1]
// 		if k, ok := orMap[res]; ok {
// 			dp[i] = max(dp[k]+1, dp[i-1])
// 		} else {
// 			dp[i] = dp[i-1]
// 		}
// 		orMap[res] = i
// 	}
// 	return dp[len(inputs)]
// }

// func f(s string, t string) string {
// 	if s == "" || t == "" {
// 		return "-1"
// 	}
// 	dp := make([]int, len(s)+1)

// 	maxvalue, index := 0, 0
// 	pre := 0
// 	for i := 1; i <= len(s); i++ {
// 		pre = 0
// 		for j := 1; j <= len(t); j++ {
// 			if s[i-1] == t[j-1] {
// 				num := pre + 1
// 				pre = dp[j]
// 				dp[j] = num
// 				if maxvalue < dp[j] {
// 					maxvalue = dp[j]
// 					index = i
// 				}
// 			} else {
// 				pre = dp[j]
// 				dp[j] = 0
// 			}
// 		}
// 	}
// 	str := s[index-maxvalue : index]
// 	if str == "" {
// 		return "-1"
// 	}
// 	return str
// }

// func f(s, t string) string {
// 	if len(s) == 0 || len(t) == 0 {
// 		return ""
// 	}
// 	dp := make([][]int, len(s)+1)
// 	for i := 0; i < len(dp); i++ {
// 		dp[i] = make([]int, len(t)+1)
// 	}
// 	for i := 1; i < len(dp); i++ {
// 		for j := 1; j < len(dp[0]); j++ {
// 			if s[i-1] == t[j-1] {
// 				dp[i][j] = 1 + dp[i-1][j-1]
// 			}
// 			dp[i][j] = max(dp[i][j], max(dp[i-1][j], dp[i][j-1]))
// 		}
// 	}
// 	// fmt.Println(dp)

// 	return g(dp, s, t)

// }

// func g(dp [][]int, s string, t string) string {
// 	str := ""
// 	i, j := len(dp)-1, len(dp[0])-1
// 	res := dp[i][j]
// 	for i > 0 && j > 0 && res > 0 {
// 		if dp[i][j] == dp[i][j-1] {
// 			j--
// 		} else if dp[i][j] == dp[i-1][j] {
// 			i--
// 		} else {
// 			str = string(s[i-1]) + str
// 			i--
// 			j--
// 			res--
// 		}
// 	}
// 	return str
// }

// func f(inputs [][]int) int {
// 	if len(inputs) == 0 {
// 		return 0
// 	}
// 	sort.Slice(inputs, func(i, j int) bool {
// 		return inputs[i][0] < inputs[j][0] ||
// 			(inputs[i][0] == inputs[j][0] && inputs[i][1] > inputs[j][1])
// 	})
// 	fmt.Println(inputs)

// 	ends := make([][]int, len(inputs))
// 	ends[0] = inputs[0]
// 	right := 0
// 	for i := 1; i < len(inputs); i++ {
// 		l, r := 0, right
// 		for l <= r {
// 			m := (l + r) / 2
// 			if ends[m][1] < inputs[i][1] {
// 				l = m + 1
// 			} else {
// 				r = m - 1
// 			}
// 		}
// 		right = max(l, right)
// 		ends[l] = inputs[i]
// 		fmt.Println(ends)
// 	}
// 	return right + 1
// }

// func f(inputs [][]int) int {
// 	if len(inputs) == 0 {
// 		return 0
// 	}
// 	sort.Slice(inputs, func(i, j int) bool {
// 		return inputs[i][0] < inputs[j][0] ||
// 			(inputs[i][0] == inputs[j][0] && inputs[i][1] < inputs[j][1])
// 	})
// 	fmt.Println(inputs)
// 	dp := make([]int, len(inputs))
// 	for i := 0; i < len(dp); i++ {
// 		dp[i] = 1
// 	}
// 	maxval := 1
// 	for i := 1; i < len(inputs); i++ {
// 		for j := 0; j < i; j++ {
// 			if inputs[i][0] > inputs[j][0] && inputs[i][1] > inputs[j][1] {
// 				dp[i] = max(dp[i], dp[j]+1)
// 			}
// 		}
// 		if maxval < dp[i] {
// 			maxval = dp[i]
// 		}
// 	}
// 	return maxval
// }

// func f(inputs []int) []int {
// 	if len(inputs) == 0 {
// 		return nil
// 	}

// 	d := make([]int, len(inputs))
// 	ends := make([]int, len(inputs))
// 	maxvalue, index := 1, 0
// 	right := 0
// 	d[0], ends[0] = 1, inputs[0]

// 	for i := 1; i < len(inputs); i++ {
// 		l, r := 0, right
// 		for l <= r {
// 			m := (l + r) / 2
// 			if ends[m] < inputs[i] {
// 				l = m + 1
// 			} else {
// 				r = m - 1
// 			}
// 		}
// 		right = max(right, l)
// 		ends[l] = inputs[i]
// 		d[i] = l + 1
// 		if maxvalue < l+1 {
// 			maxvalue = l + 1
// 			index = i
// 		} else if maxvalue == l+1 && inputs[index] > inputs[i] {
// 			index = i
// 		}
// 	}

// 	res := make([]int, maxvalue)
// 	for i, j := index, 0; i >= 0 && maxvalue != 0; i-- {
// 		if d[i] == maxvalue {
// 			if i-1 >= 0  && inputs[i-1] < inputs[i] { //最小字典序
// 				continue
// 			}
// 			maxvalue--
// 			res[len(res)-j-1] = inputs[i]
// 			j++
// 		}
// 	}
// 	return res
// }

// func f(inputs []int) []int {
// 	if len(inputs) == 0 {
// 		return nil
// 	}
// 	d := make([]int, len(inputs))
// 	maxvalue, index := math.MinInt32, -1
// 	for i := 0; i < len(inputs); i++ {
// 		d[i] = 1
// 		for j := 0; j < i; j++ {
// 			if inputs[i] > inputs[j] {
// 				d[i] = max(d[i], d[j]+1)
// 			}
// 		}
// 		if d[i] > maxvalue {
// 			maxvalue = d[i]
// 			index = i
// 		}
// 	}

// 	res := make([]int, maxvalue)
// 	for i, j := index, 0; i >= 0 && maxvalue != 0; i-- {
// 		if d[i] == maxvalue {
// 			maxvalue--
// 			res[len(res)-j-1] = inputs[i]
// 			j++
// 		}
// 	}
// 	return res
// }

// func f(inputs []int) int {
// 	if len(inputs) == 0 {
// 		return 0
// 	}
// 	n := len(inputs)
// 	inputs = append([]int{1}, append(inputs, []int{1}...)...)
// 	dp := make([][]int, n+2)
// 	for i := 0; i < n+2; i++ {
// 		dp[i] = make([]int, n+2)
// 	}
// 	for i := 1; i <= n; i++ {
// 		dp[i][i] = inputs[i-1] * inputs[i] * inputs[i+1]
// 	}
// 	for i := n - 1; i >= 1; i-- {
// 		dp[i][i] = inputs[i-1] * inputs[i] * inputs[i+1]
// 		for j := i + 1; j <= n; j++ {
// 			for k := i; k <= j; k++ {
// 				dp[i][j] = max(dp[i][j], inputs[i-1]*inputs[k]*
// 					inputs[j+1]+dp[i][k-1]+dp[k+1][j])
// 			}

// 		}
// 	}
// 	return dp[1][n]
// }

// func f(n int, inputs []int) int {
// 	if n == 0 {
// 		return 1
// 	}

// 	dp := make([]int, n+1)
// 	dp[0] = 1
// 	for i := 0; i < len(inputs); i++ {
// 		for j := 0; j < n+1; j++ {
// 			if j-inputs[i] >= 0 {
// 				dp[j] = (dp[j] + dp[j-inputs[i]]) % (1e9 + 7)
// 			}
// 		}
// 	}
// 	return dp[n]
// }

// func f(n int,inputs []int) int{
// 	if n == 0{
// 		return 1
// 	}
// 	ans := 0

// }
// func f(N, M, K, P int) int {
// 	dp := make([]int, N+2)
// 	if P-1 >= 1 {
// 		dp[P-1] = 1
// 	}
// 	if P+1 <= N {
// 		dp[P+1] = 1
// 	}
// 	pre := 0
// 	for i := 0; i < K-1; i++ {
// 		for j := 1; j <= N; j++ {
// 			num := (pre + dp[j+1]) % (1000000007)
// 			pre = dp[j]
// 			dp[j] = num
// 		}
// 		pre = 0
// 	}
// 	return dp[M]
// }

// func f(n int, nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	f := make([]int, n+1)

// 	for i := 1; i <= n; i++ {
// 		f[i] = math.MaxInt32
// 		for j := 0; j < len(nums); j++ {
//             if i-nums[j] >= 0{
// 				f[i] = min(f[i], f[i-nums[j]]+1)
// 			}
// 		}

// 	}
//     if f[n] == math.MaxInt32{
//         return -1
//     }
// 	return f[n]
// }

// func c3(n int) int {
// 	if n < 1 {
// 		return 0
// 	}
// 	if n == 1 || n == 2 || n == 3 {
// 		return n
// 	}
// 	base := [][]int{{1, 1, 0}, {0, 0, 1}, {1, 0, 0}}
// 	res := matrixPower(base, n-3)
// 	return 3*res[0][0] + 2*res[1][0] + res[2][0]
// }

// func SumNn(number int, n int) int {
// 	if n == 0 {
// 		return 1
// 	}
// 	res := 1
// 	tmp := number
// 	for ; n != 0; n = n >> 1 {
// 		if (n & 1) == 1 {
// 			res *= tmp
// 		}
// 		tmp *= tmp
// 	}
// 	return res
// }

// func searchRange(nums []int, target int) []int {
// 	if len(nums) == 0 {
// 		return []int{-1, -1}
// 	}
// 	return []int{searchLeft(nums, target), searchRight(nums, target)}
// }

// func searchLeft(nums []int, x	 int) int {
// 	n := len(nums)
// 	l, r := 0, n-1
// 	for l <= r {
// 		m := (l + r) / 2
// 		if nums[m] >= target {
// 			r = m - 1
// 		} else {
// 			l = m + 1
// 		}
// 	}
// 	if l < n && nums[l] == target {
// 		return l
// 	}
// 	return -1
// }

// func searchRight(nums []int, target int) int {
// 	n := len(nums)
// 	l, r := 0, n-1
// 	for l <= r {
// 		m := (l + r) / 2
// 		if nums[m] <= target {
// 			l = m + 1
// 		} else {
// 			r = m - 1
// 		}
// 	}
// 	if r >= 0 && nums[r] == target {
// 		return r
// 	}
// 	return -1
// }

// func minPathSum(inputs [][]int) int {
// 	more := max(len(inputs), len(inputs[0]))
// 	less := min(len(inputs), len(inputs[0]))
// 	rowmmore := (more == len(inputs))
// 	f := make([]int, less)
// 	f[0] = inputs[0][0]
// 	for i := 1; i < less; i++ {
// 		if rowmmore {
// 			f[i] = inputs[i][0] + f[i-1]
// 		} else {

// 			f[i] = inputs[0][i] + f[i-1]
// 		}
// 	}
// 	for i := 1; i < len(inputs); i++ {
// 		if rowmmore {

// 			f[0] = inputs[0][i] + f[0]
// 		} else {

// 			f[0] = inputs[i][0] + f[0]
// 		}

// 		for j := 1; j < len(inputs[0]); j++ {
// 			if rowmmore {
// 				f[j] = inputs[j][i] + min(f[j], f[j-1])
// 			} else {
// 				f[j] = inputs[i][j] + min(f[j], f[j-1])
// 			}

// 		}
// 	}

// 	return f[len(inputs[0])-1]
// }

// func minPathSum(inputs [][]int) int {

// 	more := max(len(inputs), len(inputs[0]))
// 	less := min(len(inputs), len(inputs[0]))
// 	rowmmore := (more == len(inputs))
// 	f := make([]int, less)
// 	f[0] = inputs[0][0]
// 	for i := 1; i < less; i++ {
// 		if rowmmore {
// 			f[i] = inputs[i][0] + f[i-1]
// 		} else {

// 			f[i] = inputs[0][i] + f[i-1]
// 		}
// 	}
// 	for i := 1; i < len(inputs); i++ {
// 		if rowmmore {

// 			f[0] = inputs[0][i] + f[0]
// 		} else {

// 			f[0] = inputs[i][0] + f[0]
// 		}

// 		for j := 1; j < len(inputs[0]); j++ {
// 			if rowmmore {
// 				f[j] = inputs[j][i] + min(f[j], f[j-1])
// 			} else {
// 				f[j] = inputs[i][j] + min(f[j], f[j-1])
// 			}

// 		}
// 	}

// 	return f[len(inputs[0])-1]
// }

// func matrixPower(m [][]int, p int) [][]int {
// 	res := make([][]int, len(m))
// 	for i := 0; i < len(res); i++ {
// 		res[i] = make([]int, len(m[0]))
// 		res[i][i] = 1
// 	}
// 	tmp := m
// 	for ; p != 0; p = p >> 1 {
// 		if (p & 1) != 0 {
// 			res = muliMatrix(res, tmp)
// 		}
// 		tmp = muliMatrix(tmp, tmp)
// 	}
// 	return res
// }
// func muliMatrix(m1 [][]int, m2 [][]int) [][]int {
// 	res := make([][]int, len(m1))
// 	for i := 0; i < len(res); i++ {
// 		res[i] = make([]int, len(m1[0]))
// 	}
// 	for i := 0; i < len(m1); i++ {
// 		for j := 0; j < len(m2[0]); j++ {
// 			for k := 0; k < len(m2); k++ {
// 				res[i][j] = (res[i][j] + m1[i][k]*m2[k][j]) % (1e9 + 7)
// 			}
// 		}
// 	}
// 	return res

// }
// func f(n int) int {
// 	if n < 1 {
// 		return 0
// 	}
// 	if n == 1 || n == 2 {
// 		return 1
// 	}
// 	base := [][]int{{1, 1}, {1, 0}}
// 	res := matrixPower(base, n-2)
// 	return res[0][0] + res[1][0]
// }

// func haha(s []int) {

// }

// type getdir struct {
// 	common     *TreeNode
// 	startValue string
// 	destValue  string
// }

// func getDirections(root *TreeNode, startValue int, destValue int) string {
// 	var findCommonhead func(root *TreeNode) *TreeNode
// 	findCommonhead = func(root *TreeNode) *TreeNode {
// 		if root == nil {
// 			return nil
// 		}
// 		left := findCommonhead(root.Left)
// 		right := findCommonhead(root.Right)
// 		if left != nil && right != nil {
// 			return root
// 		}
// 		if left != nil || right != nil {
// 			if left != nil {
// 				return left
// 			} else {
// 				return right
// 			}
// 		}
// 		if root.Val == startValue || root.Val == startValue {
// 			return root
// 		}
// 		return nil
// 	}
// 	common := findCommonhead(root)
// 	strs := make([]string, 0)
// 	var dfs func(root *TreeNode, str string)
// 	dfs = func(root *TreeNode, str string) {
// 		if root == nil {
// 			return
// 		}
// 		if root.Val == startValue {
// 			strs = append([]string{str}, strs...)
// 			return
// 		} else if root.Val == destValue {
// 			strs = append(strs, str)
// 			return
// 		}
// 		dfs(root.Left, str+"L")
// 		dfs(root.Right, str+"R")
// 	}
// 	if common.Val == startValue {
// 		dfs(common.Left, "")
// 		if len(strs) != 0 {
// 			return "L" + strs[0]
// 		}
// 		dfs(common.Right, "")
// 		if len(strs) != 0 {
// 			return "R" + strs[0]
// 		}
// 	} else if common.Val == destValue {
// 		dfs(common, "")
// 		str := ""
// 		for i := 0; i < len(strs[0]); i++ {
// 			str += "U"
// 		}
// 		return str

// 	} else {
// 		dfs(root, "")
// 		str := ""
// 		for i := 0; i < len(strs[0]); i++ {
// 			str += "U"
// 		}
// 		str += strs[1]
// 		return str
// 	}
// 	return ""
// }

// func findEvenNumbers(digits []int) []int {
// 	if len(digits) == 0 {
// 		return nil
// 	}
// 	res := make([]int, 0)
// 	indexs := make([]int, len(digits))
// 	resindex := make(map[int]bool)
// 	var dfs func(length int, value int)
// 	dfs = func(length int, value int) {
// 		if length == 3 {
// 			if value%2 == 0 && !resindex[value] {
// 				res = append(res, value)
// 				resindex[value] = true
// 				return
// 			}
// 			return
// 		}
// 		for i := 0; i < len(digits); i++ {
// 			if indexs[i] == 1 || i != 0 && indexs[i-1] != 1 && digits[i-1] == digits[i] {
// 				continue
// 			}
// 			indexs[i] = 1
// 			dfs(length+1, value*10+digits[i])
// 			indexs[i] = 0
// 		}
// 	}
// 	sort.Ints(digits)
// 	for i := 0; i < len(digits); i++ {
// 		if digits[i] == 0 || i != 0 && digits[i] == digits[i-1] {
// 			continue
// 		}
// 		indexs[i] = 1
// 		dfs(1, digits[i])
// 		indexs[i] = 0
// 	}
// 	return res
// }

// func deleteMiddle(head *ListNode) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	dump := &ListNode{}
// 	dump.Next = head
// 	temp := dump
// 	for head != nil && head.Next != nil {
// 		head = head.Next.Next
// 		temp = temp.Next
// 	}
// 	temp.Next = temp.Next.Next
// 	return dump.Next
// }

// func inorderSuccessor(root *TreeNode, p *TreeNode) *TreeNode {
// 	if root == nil {
// 		return nil
// 	}
// 	var dfs func(root *TreeNode) (*TreeNode, bool)
// 	dfs = func(root *TreeNode) (*TreeNode, bool) {
// 		if root == nil {
// 			return nil, false
// 		}
// 		l, ok := dfs(root.Left)
// 		if l != nil {
// 			if ok {
// 				return l, true
// 			} else {
// 				return root, true
// 			}
// 		}
// 		r, ok := dfs(root.Right)
// 		if r != nil {
// 			if ok {
// 				return root, true
// 			} else {
// 				return r, false
// 			}
// 		}
// 		if root == p {
// 			if root.Right != nil{
// 				return root.Right,true
// 			}
// 			return root,false
// 		}
// 		return nil, false
// 	}
// 	k, _ := dfs(root)
// 	return k
// }

// func convertBST(root *TreeNode) *TreeNode {
// 	if root == nil {
// 		return nil
// 	}
// 	var dfs func(root *TreeNode, value int) int
// 	dfs = func(root *TreeNode, value int) int {
// 		if root == nil {
// 			return 0 + value
// 		}
// 		r := dfs(root.Right, value)
// 		root.Val = r + root.Val
// 		l := dfs(root.Right, root.Val)
// 		return l
// 	}
// 	dfs(root, 0)
// 	return root
// }

// type BSTIterator struct {
// 	root  *TreeNode
// 	index int
// 	nums  []int
// }

// func Constructor(root *TreeNode) BSTIterator {
// 	var dfs func(root *TreeNode) []int
// 	dfs = func(root *TreeNode) []int {
// 		if root == nil {
// 			return nil
// 		}
// 		res := []int{}
// 		l := dfs(root.Left)
// 		res = append(res, l...)
// 		res = append(res, root.Val)
// 		r := dfs(root.Right)
// 		res = append(res, r...)
// 		return res
// 	}
// 	n := dfs(root)
// 	bst := BSTIterator{
// 		root:  root,
// 		index: 0,
// 		nums:  n,
// 	}
// 	return bst
// }

// func (this *BSTIterator) Next() int {
// 	v := this.nums[this.index]
// 	this.index++
// 	return v
// }

// func (this *BSTIterator) HasNext() bool {
// 	if this.index == len(this.nums) {
// 		return false
// 	}
// 	return true
// }

// func findRedundantConnection(edges [][]int) []int {
// 	d := make([]int, len(edges)+1)
// 	for i := 0; i < len(d); i++ {
// 		d[i] = i
// 	}
// 	var find func(x int) int
// 	find = func(x int) int {
// 		if d[x] != x {
// 			d[x] = find(d[x])
// 		}
// 		return d[x]
// 	}
// 	var union func(x, y int) bool
// 	union = func(x, y int) bool {
// 		a, b := find(x), find(y)
// 		if a == b {
// 			return false
// 		}
// 		d[x] = y
// 		fmt.Println(d)
// 		return true
// 	}
// 	for i := 0; i < len(edges); i++ {
// 		if !union(edges[i][0], edges[i][1]) {
// 			return edges[i]
// 		}
// 	}
// 	return nil
// }

// type MyCalendar struct {
// 	calendar *IntHeap
// }

// func Constructor() MyCalendar {
// 	c := &IntHeap{}
// 	heap.Init(c)
// 	mc := MyCalendar{
// 		calendar: c,
// 	}
// 	return mc
// }

// func (this *MyCalendar) Book(start int, end int) bool {
// 	k := [2]int{start, end}
// 	for i := 0; i < len(*this.calendar); i++ {
// 		if start >= (*this.calendar)[i][1] || end < (*this.calendar)[i][0] {
// 			continue
// 		} else {
// 			return false
// 		}
// 	}
// 	heap.Push(this.calendar, k)
// 	return true
// }

// type IntHeap [][2]int

// func (h IntHeap) Swap(i, j int) {
// 	h[i], h[j] = h[j], h[i]
// }
// func (h IntHeap) Len() int {
// 	return len(h)
// }
// func (h IntHeap) Less(i, j int) bool {
// 	return h[i][0] < h[j][0]
// }

// func (h *IntHeap) Pop() interface{} {
// 	old := *h
// 	x := old[len(old)-1]
// 	*h = old[0 : len(old)-1]
// 	return x
// }

// func (h *IntHeap) Push(x interface{}) {
// 	*h = append(*h, x.([2]int))
// }

// type KthLargest struct {
// 	k int
// 	nums []int
// }

// func Constructor(k int, nums []int) KthLargest {

// }

// func (this *KthLargest) Add(val int) int {

// }

// type IntHeap int
// func replaceWords(dictionary []string, sentence string) string {
// 	if len(dictionary) == 0 {
// 		return sentence
// 	}
// 	str := strings.Split(sentence, " ")
// 	dicmap := make(map[string]bool)
// 	for i := 0; i < len(dictionary); i++ {
// 		dicmap[dictionary[i]] = true
// 	}
// 	for i := 0; i < len(str); i++ {
// 		for j := 1; j < len(str[i]); j++ {
// 			if _, ok := dicmap[str[i][:j]]; ok {
// 				str[i] = str[i][:j]
// 			}
// 		}
// 	}
// 	res := strings.Join(str, " ")
// 	return res
// }
// func kSmallestPairs(nums1 []int, nums2 []int, k int) [][]int {
// 	h := IntHeap{}
// 	result := make([][]int, 0)
// 	if len(nums1) == 0 || len(nums2) == 0 {
// 		return nil
// 	}
// 	for i := 0; i < len(nums1); i++ {
// 		for j := 0; j < len(nums2); j++ {
// 			p := []int{nums1[i], nums2[j]}
// 			heap.Push(&h, p)
// 		}
// 	}
// 	for k != 0 {
// 		if len(h) == 0 {
// 			return result
// 		}
// 		res := heap.Pop(&h).([]int)
// 		result = append(result, res)
// 	}
// 	return result
// }

// type IntHeap [][]int

// func (h IntHeap) Len() int {
// 	return len(h)
// }
// func (h IntHeap) Less(i, j int) bool {
// 	return h[i][0]+h[i][1] < h[j][0]+h[j][1]
// }
// func (h IntHeap) Swap(i, j int) {
// 	h[i], h[j] = h[j], h[i]
// }
// func (h *IntHeap) Push(x interface{}) {
// 	*h = append(*h, x.([]int))
// }
// func (h *IntHeap) Pop() interface{} {
// 	tail := (*h)[len(*h)-1]
// 	*h = (*h)[:len(*h)-1]
// 	return tail
// }

//func asteroidCollision(asteroids []int) []int {
// 	if len(asteroids) == 0 {
// 		return nil
// 	}
// 	stack := []int{}

// 	for i := 0; i < len(asteroids); i++ {
// 	LOOP:
// 		if len(stack) == 0 || stack[len(stack)-1] < 0 || asteroids[i] > 0 {
// 			stack = append(stack, asteroids[i])
// 			continue
// 		}

// 		if asteroids[i] < 0 {
// 			if stack[len(stack)-1]+asteroids[i] > 0 {
// 				continue
// 			}
// 			if stack[len(stack)-1]+asteroids[i] == 0 {
// 				stack = stack[:len(stack)-1]
// 				continue
// 			}
// 			if stack[len(stack)-1]+asteroids[i] < 0 {
// 				stack = stack[:len(stack)-1]
// 				goto LOOP

// 			}
// 		}
// 	}
// 	return stack
// }

// func isAlienSorted(words []string, order string) bool {
// 	omap := make(map[byte]int)
// 	for i := 0; i < len(order); i++ {
// 		omap[order[i]-'a'] = i
// 	}
// 	for i := 1; i < len(words); i++ {

// 		if omap[words[i][0]] < omap[words[i-1][0]] {
// 			return false
// 		}

// 	}
// 	return true
// }

// func groupAnagrams(strs []string) [][]string {
// 	if len(strs) == 0 {
// 		return nil
// 	}
// 	result := make([][]string, 0)
// 	smap := make(map[[26]byte][]string)

// 	for i := 0; i < len(strs); i++ {
// 		index := [26]byte{}
// 		for j := 0; j < len(strs[i]); j++ {
// 			index[strs[i][j]-'a']++
// 		}
// 		if _, ok := smap[index]; ok {
// 			smap[index] = append(smap[index], strs[i])
// 		} else {
// 			smap[index] = make([]string, 0)
// 			smap[index] = append(smap[index], strs[i])
// 		}
// 	}
// 	for i, _ := range smap {
// 		result = append(result, smap[i])
// 	}
// 	return result
// }

// func isAnagram(s string, t string) bool {
// 	if len(s) != len(t) || s == t {
// 		return false
// 	}
// 	smap := make(map[byte]int)
// 	for i := 0; i < len(s); i++ {
// 		smap[s[i]]++
// 	}
// 	for i := 0; i < len(t); i++ {
// 		if v, ok := smap[t[i]]; !ok || v == 0 {
// 			return false
// 		}
// 		smap[t[i]]--
// 	}
// 	return true
// }

// func defer_call() {
// 	defer func() { fmt.Println("defer: panic last") }()
// 	defer func() {
// 		fmt.Println("defer: panic 之前1, 捕获异常")
// 		if err := recover(); err != nil {
// 			fmt.Println(err)
// 		}
// 	}()

// 	defer func() { fmt.Println("defer: panic 之前2, 不捕获") }()

// 	panic("异常内容") //触发defer出栈

// 	defer func() { fmt.Println("defer: panic 之后, 永远执行不到") }()
// }

// func minCost(costs [][]int) int {
// 	if len(costs) == 0 || len(costs[0]) == 0 {
// 		return 0
// 	}

// 	for i := 1; i < len(costs); i++ {
// 		costs[i][0] = costs[i][0] + min(costs[i-1][1], costs[i-1][2])
// 		costs[i][1] = costs[i][1] + min(costs[i-1][0], costs[i-1][2])
// 		costs[i][2] = costs[i][2] + min(costs[i-1][0], costs[i-1][1])
// 	}
// 	return min(costs[len(costs)-1][0], min(costs[len(costs)-1][1], costs[len(costs)-1][2]))
// }

// func minFlipsMonoIncr(s string) int {
// 	//1.找到最左边的1 or 找到最右边的0
// 	one, zero := len(s), -1
// 	ans := 0
// 	for i := len(s) - 1; i >= 0; i-- {
// 		if s[i] == '0' {
// 			zero = i
// 			break
// 		}
// 	}
// 	for i := 0; i < len(s); i++ {
// 		if s[i] == '1' {
// 			one = i
// 			break
// 		}
// 	}
// 	for i := 0; i < zero; i++ {
// 		if s[i] == '1' {
// 			ans++
// 		}
// 	}
// 	v := 0
// 	for i := one + 1; i < len(s); i++ {
// 		if s[i] == '0' {
// 			v++
// 		}
// 	}
// 	return min(v, ans)
// }

// func rob(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	if len(nums) == 1 {
// 		return nums[0]
// 	}
// 	f := make([]int, 2)
// 	g := make([]int, 2)
// 	f[0] = nums[0]
// 	f[1] = nums[0]
// 	g[0] = 0
// 	g[1] = nums[1]
// 	for i := 2; i < len(nums)-1; i++ {
// 		f[i] = max(f[(i-2)%2]+nums[i], f[(i-1)%2])
// 	}
// 	for i := 2; i < len(nums); i++ {
// 		g[i] = max(g[(i-2)%2]+nums[i], g[(i-1)%2])
// 	}
// 	return max(f[(len(nums)-2)%2], g[(len(nums)-1)%2])
// }

// func main() {

// 	fmt.Println(countSubstrings("aaa"))
// }
// func flatten(root *Node) *Node {
// 	if root == nil {
// 		return nil
// 	}
// 	dump := &Node{}
// 	var dfs func(*Node) *Node
// 	dfs = func(root *Node) *Node {
// 		if root == nil {
// 			return nil
// 		}
// 		next := root.Next
// 		root.Child.Prev = root
// 		root.Next = dfs(root.Child)

// 		for root.Next != nil {
// 			root = root.Next
// 		}
// 		root.Next = next
// 		next.Prev = root
// 		return root
// 	}
// 	dump.Next = dfs(root)
// 	return dump.Next
// }

// func countSubstrings(s string) int {
// 	var reverseSub func(index int)
// 	result := 0
// 	if len(s) == 0 {
// 		return 0
// 	}
// 	dp := make([][]bool, len(s))
// 	for i := 0; i < len(s); i++ {
// 		dp[i] = make([]bool, len(s))
// 	}
// 	for i := len(s) - 1; i >= 0; i-- {
// 		for j := i; j < len(s); j++ {
// 			if i == j || i-j < 2 || (s[i] == s[j] && dp[i+1][j-1]) {
// 				dp[i][j] = true
// 			}
// 		}
// 	}
// 	fmt.Println(dp)
// 	reverseSub = func(index int) {
// 		if index == len(s) {
// 			return
// 		}
// 		for i := index; i < len(s); i++ {
// 			if dp[index][i] {
// 				result++
// 			}
// 		}
// 	}
// 	for i := 0; i < len(s); i++ {
// 		reverseSub(i)
// 	}
// 	return result
// }

// func findAnagrams(s string, p string) []int {
// 	n, m := len(p), len(s)
// 	if n > m {
// 		return nil
// 	}
// 	res := make([]int, 0)
// 	cnt := [26]int{}
// 	for _, ch := range p {
// 		cnt[ch-'a']--
// 	}
// 	left := 0
// 	for right, ch := range s {
// 		x := ch - 'a'
// 		cnt[x]++
// 		for cnt[x] > 0 {
// 			cnt[s[left]-'a']--
// 			left++
// 		}
// 		if right-left+1 == n {
// 			res = append(res, left)
// 			cnt[s[left]-'a']--
// 			left++
// 		}
// 	}
// 	return res
// }
// func minWindow(s string, t string) string {

// }
// func checkInclusion(s1, s2 string) bool {
// 	n, m := len(s1), len(s2)
// 	if n > m {
// 		return false
// 	}
// 	cnt := [26]int{}
// 	for _, ch := range s1 {
// 		cnt[ch-'a']--
// 	}
// 	left := 0
// 	for right, ch := range s2 {
// 		x := ch - 'a'
// 		cnt[x]++
// 		for cnt[x] > 0 {
// 			cnt[s2[left]-'a']--
// 			left++
// 		}
// 		if right-left+1 == n {
// 			return true
// 		}
// 	}
// 	return false
// }

// func checkInclusion(s1 string, s2 string) bool {
// 	if len(s2) < len(s1) {
// 		return false
// 	}

// 	strindex := make(map[string]bool)
// 	str := make([]string, 0)

// 	numsindex := make([]int, len(s1))

// 	var dfs func(index int)
// 	dfs = func(index int) {
// 		if len(str) == len(s1) {
// 			r := strings.Join(str, "")
// 			strindex[r] = true
// 		}
// 		for i := 0; i < len(s1); i++ {
// 			if numsindex[i] == 1 {
// 				continue
// 			}
// 			str = append(str, string(s1[i]))
// 			numsindex[i] = 1
// 			dfs(i + 1)
// 			numsindex[i] = 0
// 			str = str[:len(str)-1]
// 		}
// 	}
// 	for i := 0; i < len(s1); i++ {
// 		numsindex[i] = 1
// 		str = append(str, string(s1[i]))
// 		dfs(i)
// 		str = str[:len(str)-1]
// 		numsindex[i] = 0
// 	}

// 	for i := len(s1) - 1; i < len(s2); i++ {
// 		// if _, ok := strindex[s2[i-len(s1)+1:i+1]]; ok {
// 		// 	return true
// 		// }
// 		if strindex[s2[i-len(s1)+1:i+1]] {
// 			return true
// 		}
// 	}
// 	return false
// }

// type NumMatrix struct {
// 	matrix [][]int
// }

// func Constructor(matrix [][]int) NumMatrix {
// 	f := NumMatrix{
// 		matrix: make([][]int, len(matrix)+1),
// 	}
// 	for i := 0; i <= len(matrix); i++ {
// 		f.matrix[i] = make([]int, len(matrix[0]))
// 	}
// 	for i:=1;i<len(matrix);i++{
// 		for j:=1
// 	}
// }

// func (this *NumMatrix) SumRegion(row1 int, col1 int, row2 int, col2 int) int {

// }

// type NumArray struct {
// 	nums []int
// }

// func Constructor(nums []int) NumArray {
// 	f := NumArray{
// 		nums: make([]int, len(nums)+1),
// 	}
// 	for i := 1; i <= len(nums); i++ {
// 		f.nums[i] = f.nums[i-1] + nums[i-1]
// 	}
// 	return f
// }

// func (this *NumArray) SumRange(left int, right int) int {
// 	return this.nums[right+1] - this.nums[left]
// }

// func pivotIndex(nums []int) int {
// 	left := make([]int, len(nums))
// 	right := make([]int, len(nums))
// 	for i := 1; i < len(nums); i++ {
// 		left[i] = left[i-1] + nums[i-1]
// 	}
// 	for i := len(nums) - 2; i >= 0; i-- {
// 		right[i] = right[i+1] + nums[i+1]
// 	}
// 	for i := 0; i < len(nums); i++ {
// 		if left[i] == right[i] {
// 			return i
// 		}
// 	}
// 	return -1
// }

// func rob(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	f := make([]int, len(nums))
// 	f[0] = nums[0]
// 	if len(nums) > 1 {
// 		f[1] = nums[1]
// 	}
// 	max1 := f[0]
// 	for i := 2; i < len(nums); i++ {
// 		f[i] = f[i-2] + nums[i]
// 		for j := i - 3; j >= 0; j-- {
// 			f[i] = max(f[j]+nums[i], f[i])
// 		}
// 		if max1 < f[i] {
// 			max1 = f[i]
// 		}
// 	}
// 	return max1
// }

// func numSubarrayProductLessThanK(nums []int, k int) int {
// 	if k <= 1{
// 		return 0
// 	}
// 	prod,ans,left := 1,0,0
// 	for right:=0;right<len(nums);right++{
// 		prod *= nums[right]
// 		for prod >= k{
// 			prod /= nums[left]
// 			left++
// 		}
// 		ans += right - left + 1
// 	}
// 	return ans
// }
// class Solution {
//     public int numSubarrayProductLessThanK(int[] nums, int k) {
//         if (k <= 1) return 0;
//         int prod = 1, ans = 0, left = 0;
//         for (int right = 0; right < nums.length; right++) {
//             prod *= nums[right];
//             while (prod >= k) prod /= nums[left++];
//             ans += right - left + 1;
//         }
//         return ans;
//     }
// }

// func numSubarrayProductLessThanK(nums []int, k int) int {
// 	ans := 0
// 	l, r := 0, 0
// 	temp := nums[0]
// 	for r < len(nums) {
// 		if temp < k {
// 			ans++
// 			r++
// 			temp = temp * nums[r]
// 			continue
// 		} else if temp >= k {
// 			l++
// 			temp = temp / l
// 		}
// 	}
// 	return ans
// }

// func minCostClimbingStairs(cost []int) int {
// 	if len(cost) == 0 {
// 		return 0
// 	}
// 	f := make([]int, len(cost)+1)

// 	for i := 2; i <= len(cost); i++ {
// 		f[i] = min(f[i-1]+cost[i-1], f[i-2]+cost[i-2])
// 	}
// 	return f[len(cost)]
// }

// func restoreIpAddresses(s string) []string {
// 	if len(s) == 0 {
// 		return nil
// 	}
// 	var dfs func(index int)
// 	result := make([]string, 0)
// 	res := make([]string, 0)
// 	dfs = func(index int) {
// 		if index == len(s) {
// 			if len(res) == 4 {
// 				s := strings.Join(res, ".")
// 				result = append(result, s)
// 			}
// 			return
// 		}
// 		for i := index; i < len(s); i++ {
// 			if i != index && s[index] == '0' {
// 				return
// 			}

// 			value, err := strconv.ParseInt(s[index:i+1], 10, 32)
// 			if err != nil || value > 255 {
// 				return
// 			}
// 			res = append(res, s[index:i+1])
// 			dfs(i + 1)
// 			res = res[:len(res)-1]
// 		}
// 	}
// 	dfs(0)
// 	return result
// }

// func partition(s string) [][]string {
// 	if len(s) == 0 {
// 		return nil
// 	}
// 	result := make([][]string, 0)
// 	res := make([]string, 0)
// 	f := make([][]bool, len(s))
// 	for i := 0; i < len(f); i++ {
// 		f[i] = make([]bool, len(s))
// 	}
// 	for i := len(s) - 1; i >= 0; i-- {
// 		for j := i; j < len(s); j++ {
// 			if s[i] == s[j] && (j-i < 2 || f[i+1][j-1]) {
// 				f[i][j] = true
// 			}
// 		}
// 	}

// 	var reversePartition func(index int)
// 	reversePartition = func(index int) {

// 		if index == len(s) {
// 			fmt.Println(res)
// 			result = append(result, append([]string{}, res...))
// 			return
// 		}
// 		for i := index; i < len(s); i++ {
// 			if f[index][i] {
// 				res = append(res, s[index:i+1])
// 				reversePartition(i + 1)
// 				res = res[:len(res)-1]
// 			}
// 		}
// 	}
// 	reversePartition(0)
// 	return result
// }

// func generateParenthesis(n int) []string {
// 	left := n
// 	right := n
// 	result := make([]string,0)
// 	var reverseGenerate func(left int,right int) string
// 	reverseGenerate = func(left int,right int){
// 		for
// 	}

// }

// func twoSum(numbers []int, target int) []int {
// 	left, right := 0, len(numbers)-1
// 	for left < right {
// 		if numbers[left]+numbers[right] == target {
// 			return []int{left, right}
// 		} else if numbers[left]+numbers[right] > target {
// 			right--
// 		} else {
// 			left++
// 		}
// 	}
// 	return nil
// }

// func maxProduct(words []string) int {
// 	wordsindex := map[int]int{}

// 	for i := 0; i < len(words); i++ {
// 		word := 0
// 		for _, ch := range words[i] {
// 			word |= 1 << (ch - 'a')
// 		}
// 		if len(words[i]) > wordsindex[word] {
// 			wordsindex[word] = len(words[i])
// 		}
// 	}
// 	ans := 0
// 	for _, v := range wordsindex {
// 		for _, k := range wordsindex {
// 			if v&k == 0 && v*k > ans {
// 				ans = v * k
// 			}
// 		}
// 	}
// 	return ans
// }

// func maxProduct(words []string) int {
// 	maxlen := 0
// 	for i := 0; i < len(words); i++ {
// 		for j := i + 1; j < len(words); j++ {
// 			if maxstring(words[i], words[j]) {
// 				fmt.Println(words[i], words[j], len(words[i])*len(words[j]))
// 				sort.Strings()
// 				maxlen = max(maxlen, len(words[i])*len(words[j]))
// 			}
// 		}
// 	}
// 	return maxlen
// }
// func maxstring(s1 string, s2 string) bool {
// 	i, j := 0, 0
// 	for i < len(s1) && j < len(s2) {
// 		if s1[i] == s2[j] {
// 			return false
// 		} else if s1[i] > s2[j] {
// 			j++
// 		} else {
// 			i++
// 		}
// 	}
// 	return true
// }

// func permuteUnique(nums []int) [][]int {
// 	if len(nums) == 0 {
// 		return nil
// 	}
// 	result := make([][]int, 0)
// 	index := make([]int, len(nums))

// 	var reversePermute func(res []int)
// 	reversePermute = func(res []int) {
// 		if len(res) == len(nums) {
// 			result = append(result, append([]int{}, res...))
// 		}
// 		for i := 0; i < len(nums); i++ {
// 			if index[i] == 1 {
// 				continue
// 			}
// 			if i != 0 && nums[i] == nums[i-1] {
// 				continue
// 			}
// 			index[i] = 1
// 			res = append(res, nums[i])
// 			reversePermute(res)
// 			index[i] = 0
// 			res = res[:len(res)-1]
// 		}
// 	}
// 	res := make([]int, 0)
// 	for i := 0; i < len(nums); i++ {
// 		if i != 0 && nums[i] == nums[i-1] {
// 			continue
// 		}
// 		index[i] = 1
// 		res = append(res, nums[i])
// 		reversePermute(res)
// 		index[i] = 0
// 		res = res[:len(res)-1]
// 	}
// 	return result
// }
func permute(nums []int) [][]int {
	if len(nums) == 0 {
		return nil
	}
	result := make([][]int, 0)
	index := make([]int, len(nums))

	var reversePermute func(res []int)
	reversePermute = func(res []int) {
		if len(res) == len(nums) {
			result = append(result, append([]int{}, res...))
		}
		for i := 0; i < len(nums); i++ {
			if index[i] == 1 {
				continue
			}
			index[i] = 1
			res = append(res, nums[i])
			reversePermute(res)
			index[i] = 0
			res = res[:len(res)-1]
		}
	}
	res := make([]int, 0)
	for i := 0; i < len(nums); i++ {
		index[i] = 1
		res = append(res, nums[i])
		reversePermute(res)
		index[i] = 0
		res = res[:len(res)-1]
	}
	return result
}

// func singleNumber(nums []int) int {
// 	for i:=0;i<32;i++{

// 	}
// 	return result
// }

// func combinationSum2(candidates []int, target int) [][]int {
// 	if len(candidates) == 0 {
// 		return nil
// 	}
// 	result := make([][]int, 0)
// 	sort.Ints(candidates)
// 	var reverseCombination func(index int, sum int, res []int)
// 	reverseCombination = func(index int, sum int, res []int) {
// 		if sum == target {
// 			result = append(result, append([]int{}, res...))
// 			return
// 		}
// 		for i := index; i < len(candidates); i++ {
// 			if i != index && candidates[i] == candidates[i-1] {
// 				continue
// 			}
// 			if sum+candidates[i] > target {
// 				return
// 			}
// 			res = append(res, candidates[i])
// 			if sum+candidates[i] == target {
// 				result = append(result, append([]int{}, res...))
// 				res = res[:len(res)-1]
// 				return
// 			}
// 			reverseCombination(i+1, sum+candidates[i], res)
// 			res = res[:len(res)-1]
// 		}
// 	}
// 	res := make([]int, 0)
// 	for i := 0; i < len(candidates); i++ {
// 		if i != 0 && candidates[i] == candidates[i-1] {
// 			continue
// 		}
// 		res = append(res, candidates[i])
// 		reverseCombination(i+1, candidates[i], res)
// 		res = res[:len(res)-1]
// 	}
// 	return result
// }

// func addBinary(a string, b string) string {
// 	i := len(a) - 1
// 	j := len(b) - 1
// 	ans := ""
// 	k := 0
// 	for i >= 0 || j >= 0 {
// 		numa, numb := 0, 0
// 		if i >= 0 {
// 			numa = int(a[i] - '0')
// 			i--
// 		}
// 		if j >= 0 {
// 			numb = int(b[j] - '0')
// 			j--
// 		}
// 		sum := numa + numb + k
// 		if sum >= 2 {
// 			k = 1
// 			sum = 0
// 		} else {
// 			k = 0
// 		}
// 		ans = strconv.Itoa(sum) + ans
// 	}
// 	if k == 1 {
// 		ans = "1" + ans
// 	}
// 	return ans
// }

// func countBits(n int) []int {
// 	f := make([]int, n+1)
// 	f[0] = 0
// 	f[1] = 1

// 	for i := 2; i <= n; i++ {
// 		if i%2 == 0 {
// 			f[i] = 1
// 		} else {
// 			f[i] = f[i/2] + 1
// 		}
// 	}
// 	return f
// }

// func combinationSum(candidates []int, target int) [][]int {
// 	result := make([][]int, 0)
// 	sort.Ints(candidates)
// 	var reverseCombination func(index int, sum int, res []int)
// 	reverseCombination = func(index int, sum int, res []int) {
// 		if sum == target {

// 			result = append(result, append([]int{}, res...))
// 			return
// 		}
// 		for i := index; i < len(candidates); i++ {
// 			if sum+candidates[i] > target {
// 				return
// 			}
// 			res = append(res, candidates[i])
// 			if sum+candidates[i] == target {
// 				result = append(result, append([]int{}, res...))
// 				res = res[:len(res)-1]
// 				return
// 			}
// 			reverseCombination(i, sum+candidates[i], res)
// 			res = res[:len(res)-1]
// 		}
// 	}
// 	res := make([]int, 0)
// 	for i := 0; i < len(candidates); i++ {
// 		res = append(res, candidates[i])
// 		reverseCombination(i, candidates[i], res)
// 		res = res[:len(res)-1]
// 	}
// 	return result
// }

// func divide(a int, b int) int {
// 	if a == 0 {
// 		return 0
// 	}

// 	flag := true
// 	cnt := 0
// 	if a < 0 {
// 		flag = !flag
// 		a = -a
// 	}
// 	if b < 0 {
// 		flag = !flag
// 		b = -b
// 	}
// 	for a > b {
// 		temp := 1
// 		for a > b*temp {
// 			temp = temp << 1
// 		}
// 		temp = temp >> 1
// 		cnt += temp
// 		a = a - temp*b
// 	}
// 	if flag {
// 		if cnt >= math.MaxInt32 {
// 			return math.MaxInt32
// 		} else {
// 			return cnt
// 		}
// 	} else {
// 		if cnt >= math.MaxInt32-1 {
// 			return math.MinInt32
// 		} else {
// 			return -cnt
// 		}
// 	}
// }

// func findMedianSortedArrays(nums1 []int, nums2 []int) float64 {
// 	mid1, mid2 := 0, 0
// 	s1, e1 := 0, len(nums1)
// 	s2, e2 := 0, len(nums2)
// 	k := min(len(nums1), len(nums2))
// 	for s1 < e1 {
// 		mid1 = (s1 + e1) / 2
// 		mid2 = (s2 + e2) / 2
// 		offset := ((e1 - s1 + 1) & 1) ^ 1
// 		if nums1[mid1] > nums2[mid2] {
// 			e1 = mid1
// 			s2 = mid2 + offset
// 		} else if nums1[mid1] < nums2[mid2] {
// 			s1 = mid1 + offset
// 			e2 = mid2
// 		} else {
// 			return nums1[mid1]
// 		}

// 	}
// 	return min(nums1[s1], nums2[s2])
// }

// func candy(ratings []int) int {
// 	if len(ratings) == 0 {
// 		return 0
// 	}
// 	res := 0
// 	pre := 1
// 	inc := 1
// 	dec := 0

// 	for i := 1; i < len(ratings); i++ {
// 		if ratings[i+1] >= ratings[i] {
// 			if ratings[i+1] == ratings[i] {
// 				pre = 1
// 			} else {
// 				pre++
// 			}
// 			dec = 0
// 			res += pre
// 			inc = pre
// 		} else {
// 			dec++
// 			if dec == inc {
// 				dec++
// 			}
// 			res += dec
// 			pre = 1
// 		}
// 	}
// 	return res
// }

// func candy(ratings []int) int {
// 	if len(ratings) == 0 {
// 		return 0
// 	}
// 	res := 0
// 	left := make([]int, len(ratings))
// 	right := make([]int, len(ratings))
// 	for i := 0; i < len(ratings); i++ {
// 		left[i] = 1
// 		right[i] = 1
// 	}
// 	for i := 1; i < len(ratings); i++ {
// 		if ratings[i] > ratings[i-1] {
// 			left[i] = left[i-1] + 1
// 		} else {
// 			left[i] = 1
// 		}

// 		if ratings[i] > ratings[i+1] {
// 			fmt.Println("haha")
// 			right[i] = right[i+1] + 1
// 		} else {

// 			right[i] = 1

// 		}
// 	}

// 	for i := len(ratings) - 2; i >= 0; i-- {
// 		if ratings[i] > ratings[i+1] {
// 			fmt.Println("haha")
// 			right[i] = right[i+1] + 1
// 		} else {

// 			right[i] = 1

// 		}
// 		res += max(left[i], right[i])

// 	}

// 	return res
// }

// func isRectangleCover(rectangles [][]int) bool {
// 	if len(rectangles) == 0 || len(rectangles[0]) == 0 {
// 		return false
// 	}
// 	mostLeft, mostRight, mostTop, mostDown := math.MaxInt32, math.MinInt32, math.MinInt32, math.MaxInt32
// 	for i := 0; i < len(rectangles); i++ {
// 		mostLeft = min(mostLeft, rectangles[i][0])
// 		mostRight = max(mostRight, rectangles[i][2])
// 		mostTop = max(mostTop, rectangles[i][3])
// 		mostDown = min(mostDown, rectangles[i][1])
// 	}

// 	set := make(map[string]bool)
// 	area := 0
// 	for _, v := range rectangles {
// 		area += (v[2] - v[0]) * (v[3] - v[1])
// 		leftdown := string(v[0]) + "_" + string(v[1])
// 		lefttop := string(v[0]) + "_" + string(v[3])
// 		rightdown := string(v[2]) + "_" + string(v[1])
// 		righttop := string(v[2]) + "_" + string(v[3])
// 		if set[leftdown] {
// 			delete(set, leftdown)
// 		} else {
// 			set[leftdown] = true
// 		}
// 		if set[lefttop] {
// 			delete(set, lefttop)
// 		} else {
// 			set[lefttop] = true
// 		}
// 		if set[rightdown] {
// 			delete(set, rightdown)
// 		} else {
// 			set[rightdown] = true
// 		}
// 		if set[righttop] {
// 			delete(set, righttop)
// 		} else {
// 			set[righttop] = true
// 		}
// 	}
// 	if !set[string(mostLeft)+"_"+string(mostDown)] || !set[string(mostLeft)+"_"+string(mostTop)] ||
// 		!set[string(mostRight)+"_"+string(mostDown)] || !set[string(mostRight)+"_"+string(mostTop)] ||
// 		len(set) != 4 {
// 		return false
// 	}
// 	return area == (mostRight-mostLeft)*(mostTop-mostDown)
// }

// func findGCD(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	mins, maxs := nums[0], nums[0]
// 	for i := 0; i < len(nums); i++ {
// 		mins = min(mins, nums[i])
// 		maxs = max(maxs, nums[i])
// 	}
// 	var grid func(i, j int) int
// 	grid = func(i, j int) int {
// 		if j == 0 {
// 			return i
// 		}
// 		return grid(j, i%j)
// 	}
// 	return grid(maxs, mins)
// }

// func largest1BorderedSquare(grid [][]int) int {
// 	if len(grid) == 0 || len(grid[0]) == 0 {
// 		return 0
// 	}
// 	res := 0
// 	right := make([][]int, len(grid))
// 	down := make([][]int, len(grid))
// 	for i := 0; i < len(grid); i++ {
// 		right[i] = make([]int, len(grid[0]))
// 		down[i] = make([]int, len(grid[0]))
// 	}
// 	for i := 0; i < len(grid); i++ {
// 		if grid[i][len(grid[0])-1] == 1 {
// 			right[i][len(grid[0])-1] = 1
// 		}
// 		for j := len(grid[0]) - 2; j >= 0; j-- {
// 			if grid[i][j] != 1 {
// 				continue
// 			}
// 			right[i][j] = right[i][j+1] + 1
// 		}
// 	}
// 	fmt.Println(right, grid)
// 	for j := 0; j < len(grid[0]); j++ {
// 		if grid[len(grid)-1][j] == 1 {
// 			down[len(grid)-1][j] = 1
// 		}
// 		for i := len(grid) - 2; i >= 0; i-- {
// 			if grid[i][j] != 1 {
// 				continue
// 			}
// 			down[i][j] = down[i+1][j] + 1
// 		}
// 	}
// 	// fmt.Println(down, right)
// 	for i := 0; i < len(grid); i++ {
// 		for j := 0; j < len(grid[0]); j++ {
// 			k := min(right[i][j], down[i][j])
// 			if k == 0 {
// 				continue
// 			}
// 			if down[i][j+k-1] >= k && right[i+k-1][j] >= k {
// 				res = max(res, k)
// 			}
// 		}
// 	}
// 	return res * res
// }

// func subarraySum(nums []int, k int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	sum := 0
// 	res := 0
// 	nummap := make(map[int]int)
// 	nummap[0] = -1
// 	for i := 0; i < len(nums); i++ {
// 		sum += nums[i]
// 		if _, ok := nummap[sum]; !ok {
// 			nummap[sum] = i
// 		}
// 		if v, ok := nummap[sum-k]; ok {
// 			res++
// 		}
// 	}

// 	return res
// }

// func maxSubArrayLen(nums []int, k int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}

// 	left := 0
// 	right := 0
// 	sum := nums[0]
// 	minvalue := math.MaxInt32
// 	for right < len(nums) {
// 		if sum == k {
// 			minvalue = max(minvalue, right-left+1)
// 			sum -= nums[left]
// 			left++
// 		} else if sum < k {
// 			right++
// 			if right == len(nums) {
// 				break
// 			}
// 			sum += nums[right]
// 		} else {
// 			sum -= nums[left]
// 			left++
// 		}
// 	}
// 	return minvalue
// }
// func minSubArrayLen(target int, nums []int) int {
// 	k := target
// 	if len(nums) == 0 {
// 		return 0
// 	}

// 	left := 0
// 	right := 0
// 	sum := nums[0]
// 	minvalue := math.MaxInt32
// 	for right < len(nums) {
// 		if sum == k {
// 			minvalue = min(minvalue, right-left+1)
// 			sum -= nums[left]
// 			left++
// 		} else if sum < k {
// 			right++
// 			if right == len(nums) {
// 				break
// 			}
// 			sum += nums[right]
// 		} else {
// 			sum -= nums[left]
// 			left++
// 		}
// 	}
// 	return minvalue
// }
// func subarraySum(nums []int, k int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	res := 0
// 	left := 0
// 	right := 0
// 	sum := nums[0]
// 	for right < len(nums) {
// 		if sum == k {
// 			res++
// 			sum -= nums[left]
// 			left++
// 		} else if sum < k {
// 			right++
// 			if right == len(nums) {
// 				break
// 			}
// 			sum += nums[right]
// 		} else {
// 			sum -= nums[left]
// 			left++
// 		}
// 	}
// 	return res
// }

// func fourSum(nums []int, target int) [][]int {

// 	if len(nums) < 4 {
// 		return nil
// 	}
// 	sort.Ints(nums)
// 	res := make([][]int, 0)
// 	var GetthreeSum func(fi int, fj int, l int, r int, target int)
// 	GetthreeSum = func(fi int, fj int, l int, r int, target int) {
// 		for l < r {
// 			if nums[l]+nums[r] < target {
// 				l++
// 			} else if nums[l]+nums[r] > target {
// 				r--
// 			} else {
// 				if l == f+1 || nums[l] != nums[l-1] {
// 					result := []int{nums[l], nums[r], nums[fi], nums[fj]}
// 					res = append(res, result)
// 				}
// 				r--
// 				l++
// 			}
// 		}
// 	}

// 	for i := 0; i < len(nums)-3; i++ {
// 		for j := i + 1; j < len(nums)-2; j++ {
// 			if j == i+1 || nums[j] != nums[j-1] {
// 				GetthreeSum(i, j, j+1, len(nums)-1, target-nums[j]-nums[i])
// 			}
// 		}

// 	}
// 	return res
// }

// func threeSumClosest(nums []int, target int) int {
// 	if len(nums) < 3 {
// 		return nil
// 	}
// 	min := math.MaxInt32
// 	res := make([][]int, 0)
// 	var GetthreeSum func(f int, l int, r int, target int)
// 	GetthreeSum = func(f int, l int, r int, target int) {
// 		for l < r {
// 			if nums[l]+nums[r]  < target {
// 				l++
// 			} else if nums[l]+nums[r] > target {
// 				r--
// 			} else {
// 				if l == f+1 || nums[l] != nums[l-1] {
// 					result := []int{nums[l], nums[r], nums[f]}
// 					res = append(res, result)
// 				}
// 				r--
// 				l++
// 			}
// 		}
// 	}

// 	for i := 0; i < len(nums)-2; i++ {
// 		if i == 0 || nums[i] != nums[i-1] {
// 			GetthreeSum(i, i+1, len(nums)-1, target-nums[i])
// 		}
// 	}
// 	return res
// // }
// func threeSum(nums []int) [][]int {
// 	if len(nums) < 3 {
// 		return nil
// 	}
// 	res := make([][]int, 0)
// 	var GetthreeSum func(f int, l int, r int, target int)
// 	GetthreeSum = func(f int, l int, r int, target int) {
// 		for l < r {
// 			if nums[l]+nums[r] < target {
// 				l++
// 			} else if nums[l]+nums[r] > target {
// 				r--
// 			} else {
// 				if l == f+1 || nums[l] != nums[l-1] {
// 					result := []int{nums[l], nums[r], nums[f]}
// 					res = append(res, result)
// 				}
// 				r--
// 				l++
// 			}
// 		}
// 	}

// 	for i := 0; i < len(nums)-2; i++ {
// 		if i == 0 || nums[i] != nums[i-1] {
// 			GetthreeSum(i, i+1, len(nums)-1, 0-nums[i])
// 		}
// 	}
// 	return res
// }

// func singleNonDuplicate(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	start := nums[0]
// 	for i := 1; i < len(nums); i++ {
// 		start ^= nums[i]
// 	}
// 	return start
// }

// func findUnsortedSubarray(nums []int) int {
// 	left := -1
// 	right := -1
// 	min1 := nums[len(nums)-1]
// 	max1 := nums[0]
// 	for i := len(nums) - 2; i >= 0; i-- {
// 		if nums[i] > min1 {
// 			right = i
// 		} else {
// 			min1 = min(min1, nums[i])
// 		}
// 	}
// 	if right == -1 {
// 		return 0
// 	}
// 	for i := 1; i < len(nums); i++ {
// 		if nums[i] < max1 {
// 			left = i
// 		} else {
// 			max1 = max(max1, nums[i])
// 		}
// 	}
// 	return left - right + 1
// }

// func rotate(matrix [][]int) {
// 	if len(matrix) == 0 || len(matrix[0]) == 0 {
// 		return
// 	}
// 	tr, tc := 0, 0
// 	dr, dc := len(matrix)-1, len(matrix[0])-1
// 	for tr <= dr && tc <= dc {
// 		times := dc - tc
// 		tmp := 0
// 		for i := 0; i < times; i++ {
// 			tmp = matrix[tr][tc+i]
// 			matrix[tr][tc+i] = matrix[dr-i][tc]
// 			matrix[dr-i][tc] = matrix[dr][dc-i]
// 			matrix[dr][dc-i] = matrix[tr+i][tc]
// 			matrix[tr+i][tc] = tmp
// 		}
// 	}
// }

// func generateMatrix(n int) [][]int {
// 	if n == 0 {
// 		return nil
// 	}
// 	res := make([][]int, n)
// 	for i := 0; i < len(res); i++ {
// 		res[i] = make([]int, n)

// 	}
// 	indexs := make([]int, n*n)

// 	for i := 0; i < len(indexs); i++ {
// 		indexs[i] = i + 1
// 	}
// 	fmt.Println(indexs)
// 	tl, tr := 0, 0
// 	wl, wr := n-1, n-1
// 	for tl <= wl && tr <= wr {
// 		if tl == wl {
// 			for i := tr; i <= wr; i++ {
// 				res[tl][i] = indexs[tl*(n-1)+i]
// 			}
// 		} else if tr == wr {
// 			for i := tl; i <= wl; i++ {
// 				res[i][tr] = indexs[i*(n-1)+tr]
// 			}
// 		} else {
// 			cul := tl
// 			cur := tr
// 			for cur != wr {
// 				res[cul][cur] = indexs[cul*(n-1)+cur]
// 				cur++
// 			}
// 			fmt.Println("1", res)
// 			j := 0
// 			for cul != wl {
// 				res[cul][cur] = indexs[cul*(n-1)+cur]
// 				cul++
// 				j++
// 			}
// 			fmt.Println("2", res)

// 			for cur != tr {
// 				res[cul][cur] = indexs[cul*(n-1)+j]
// 				cur--

// 			}
// 			fmt.Println("3", res)
// 			for cul != tl {
// 				res[cul][cur] = indexs[cul*(n-1)+cur]
// 				cul--
// 			}
// 			fmt.Println("4", res)
// 		}
// 		tl++
// 		tr++
// 		wr--
// 		wl--
// 	}
// 	return res
// }
// func spiralOrder(matrix [][]int) []int {
// 	if len(matrix) == 0 || len(matrix[0]) == 0 {
// 		return nil
// 	}
// 	res := make([]int, 0)
// 	tl, tr := 0, 0
// 	wl, wr := len(matrix)-1, len(matrix[0])-1

// 	for tl <= wl && tr <= wr {
// 		if tl == wl {
// 			for i := tr; i <= wr; i++ {
// 				res = append(res, matrix[tl][i])
// 			}
// 		} else if tr == wr {
// 			for i := tl; i <= wl; i++ {
// 				res = append(res, matrix[i][tr])
// 			}
// 		} else {
// 			cul := tl
// 			cur := tr
// 			for cur != wr {
// 				res = append(res, matrix[cul][cur])
// 				cur++
// 			}
// 			for cul != wl {
// 				res = append(res, matrix[cul][cur])
// 				cul++
// 			}
// 			for cur != tr {
// 				res = append(res, matrix[cul][cur])
// 				cur--
// 			}
// 			for cul != tl {
// 				res = append(res, matrix[cul][cur])
// 				cul--
// 			}
// 		}
// 		tl++
// 		tr++
// 		wr--
// 		wl--
// 	}
// 	return res
// }

// const highBit = 30

// type trie struct {
//     left, right *trie
// }

// func (t *trie) add(num int) {
//     cur := t
//     for i := highBit; i >= 0; i-- {
//         bit := num >> i & 1
//         if bit == 0 {
//             if cur.left == nil {
//                 cur.left = &trie{}
//             }
//             cur = cur.left
//         } else {
//             if cur.right == nil {
//                 cur.right = &trie{}
//             }
//             cur = cur.right
//         }
//     }
// }

// func (t *trie) check(num int) (x int) {
//     cur := t
//     for i := highBit; i >= 0; i-- {
//         bit := num >> i & 1
//         if bit == 0 {
//             // a_i 的第 k 个二进制位为 0，应当往表示 1 的子节点 right 走
//             if cur.right != nil {
//                 cur = cur.right
//                 x = x*2 + 1
//             } else {
//                 cur = cur.left
//                 x = x * 2
//             }
//         } else {
//             // a_i 的第 k 个二进制位为 1，应当往表示 0 的子节点 left 走
//             if cur.left != nil {
//                 cur = cur.left
//                 x = x*2 + 1
//             } else {
//                 cur = cur.right
//                 x = x * 2
//             }
//         }
//     }
//     return
// }

// func findMaximumXOR(nums []int) (x int) {
//     root := &trie{}
//     for i := 1; i < len(nums); i++ {
//         // 将 nums[i-1] 放入字典树，此时 nums[0 .. i-1] 都在字典树中
//         root.add(nums[i-1])
//         // 将 nums[i] 看作 ai，找出最大的 x 更新答案
//         x = max(x, root.check(nums[i]))
//     }
//     return
// }

// func max(a, b int) int {
//     if a > b {
//         return a
//     }
//     return b
// }

// type Trie struct {
//     children [26]*Trie
//     isEnd    bool
// }

// func Constructor() Trie {
//     return Trie{}
// }

// func (t *Trie) Insert(word string) {
//     node := t
//     for _, ch := range word {
//         ch -= 'a'
//         if node.children[ch] == nil {
//             node.children[ch] = &Trie{}
//         }
//         node = node.children[ch]
//     }
//     node.isEnd = true
// }

// func (t *Trie) SearchPrefix(prefix string) *Trie {
//     node := t
//     for _, ch := range prefix {
//         ch -= 'a'
//         if node.children[ch] == nil {
//             return nil
//         }
//         node = node.children[ch]
//     }
//     return node
// }

// func (t *Trie) Search(word string) bool {
//     node := t.SearchPrefix(word)
//     return node != nil && node.isEnd
// }

// func (t *Trie) StartsWith(prefix string) bool {
//     return t.SearchPrefix(prefix) != nil
// }

// func partition(s string) [][]string {
// 	if len(s) == 0 {
// 		return nil
// 	}
// 	l := len(s)
// 	boolean := make([][]bool, l)
// 	for i := 0; i < l; i++ {
// 		boolean[i] = make([]bool, l)
// 	}
// 	res := make([][]string, 0)
// 	for i := l - 1; i >= 0; i-- {
// 		for j := i; j < l; j++ {
// 			if s[i] == s[j] && (j-i < 2 || boolean[i+1][j-1]) {
// 				boolean[i][j] = true
// 				res = append(res, []string{s[0:i], s[i : j+1], s[j+1:]})
// 			}
// 		}
// 	}
// 	return res
// }

// func minCut(s string) int {
// 	if len(s) == 0 {
// 		return 0
// 	}
// 	l := len(s)
// 	f := make([]int, l+1)
// 	f[l] = -1
// 	boolean := make([][]bool, l)
// 	for i := 0; i < l; i++ {
// 		boolean[i] = make([]bool, l)
// 	}
// 	for i := l - 1; i >= 0; i-- {
// 		f[i] = math.MaxInt32
// 		for j := i; i < l; j++ {
// 			if s[i] == s[j] && (j-i < 2 || boolean[i+1][j-1]) {
// 				boolean[i][j] = true
// 				f[i] = min(f[i], f[j+1]+1)
// 			}
// 		}
// 	}
// 	return f[0]
// }

// func numKLenSubstrNoRepeats(s string, k int) int {
// 	if len(s) == 0 {
// 		return 0
// 	}
// 	res := 0
// 	pre := -1
// 	smap := make(map[byte]int)
// 	for i := 0; i < len(s); i++ {
// 		if _, ok := smap[s[i]]; ok {
// 			temp := smap[s[i]]
// 			if pre < temp {
// 				pre = temp
// 			}
// 		}
// 		smap[s[i]] = i
// 		if i-pre >= k {
// 			res++
// 		}
// 	}
// 	return res
// }
func lengthOfLongestSubstring(s string) int {
	if len(s) == 0 {
		return 0
	}
	res := 0
	pre := -1
	smap := make(map[byte]int)
	for i := 0; i < len(s); i++ {
		if _, ok := smap[s[i]]; ok {
			pre = smap[s[i]]
		}
		smap[s[i]] = i
		if res < i-pre {
			res = i - pre
		}
	}
	return res
}

// func longestValidParentheses(s string) int {
// 	if len(s) == 0 {
// 		return 0
// 	}
// 	f := make([]int, len(s))
// 	for i := 1; i < len(s); i++ {
// 		if s[i] == '(' {
// 			continue
// 		}
// 		if s[i-f[i-1]-1] == '(' {
// 			f[i] = f[i-1] + 2
// 			if i-f[i-1]-2 >= 0 && f[i-f[i-1]-2] != 0 {
// 				f[i] += f[i-f[i-1]-2]
// 			}
// 		}
// 	}
// 	max := 0
// 	for _, v := range f {
// 		if max < v {
// 			max = v
// 		}
// 	}
// 	return max
// }

// func longestValidParentheses(s string) int {
// 	if len(s) == 0 {
// 		return 0
// 	}
// 	res := 0
// 	cnt := 0
// 	stack := make([]byte, 0)
// 	for i := 0; i < len(s); i++ {
// 		if s[i] == ')' {
// 			if stack[len(stack)-1] == '(' {
// 				cnt += 2
// 				stack = stack[:len(stack)-1]
// 				continue
// 			}
// 		}
// 		stack = append(stack, s[i])

// 	}
// 	return res
// }

// func minimumMoves(s string) int {
// 	if len(s) == 0 {
// 		return 0
// 	}
// 	left, right := 0, 0
// 	res := 0
// 	for right < len(s)+1 {
// 		if len(s) < 3 {
// 			right = len(s) - 1
// 		} else {
// 			right = left + 2
// 		}
// 		ok := seekMove(s[left : right+1])
// 		if ok {
// 			res++
// 		}
// 		left = right + 1
// 	}
// 	return res
// }
// func seekMove(s string) bool {
// 	for i := 0; i < len(s); i++ {
// 		if s[i] == 'X' {
// 			return true
// 		}
// 	}
// 	return false
// }

// func findTheDistanceValue(arr1 []int, arr2 []int, d int) int {
// 	//通过二分搜索，前提是对arr1做排序，arr2也是可以做排序的
// 	sort.Ints(arr1)
// 	sort.ints(arr2)
// 	if len(arr1) == 0{
// 		return 0
// 	}
// 	res := 0
// 	left,right := 0,len(arr1)-1
// 	for left + 1 < right{
// 		mid := left + (right - left) / 2
// 		if computeFind(arr1[mid],arr2,d){
// 			res += 1 + len(arr1[mid+1:])
// 		}else{
// 			right= mid
// 		}
// 	}
// 	if computeFind
// }

// func replaceSpace(s string) string {

// 	res := s[:]
// 	cur, temp := len(res)-1, len(res)-1
// 	for i := len(res) - 1; i >= 0; i-- {
// 		if res[i] == '*' {
// 			cur--
// 		} else {
// 			res[cur], res[temp] = string(res[temp]), string(res[cur])
// 		}
// 	}
// }

//
// func replaceSpace(s string) string {
// 	if len(s) == 0 {
// 		return s
// 	}
// 	res := strings.Replace(s, " ", "%20", -1)
// 	return res
// }

// func heapSort(chas []byte) {

// 	for i := 0; i < len(chas); i++ {
// 		heapInsert(chas, i)
// 	}
// 	for i := len(chas) - 1; i > 0; i-- {
// 		swap(chas, 0, i)
// 		heapify(chas, 0, i)
// 	}

// }

// func heapInsert(chas []byte, i int) {
// 	parent := 0
// 	for i != 0 {
// 		parent = (i - 1) / 2
// 		if chas[parent] < chas[i] {
// 			swap(chas, parent, i)
// 			i = parent
// 		} else {
// 			break
// 		}
// 	}
// }

// func heapify(chas []byte, i int, size int) {
// 	left := i*2 + 1
// 	right := i*2 + 2
// 	largest := i
// 	for left < size {
// 		if chas[left] > chas[i] {
// 			largest = right
// 		}
// 		if right < size && chas[right] > chas[largest] {
// 			largest = right
// 		}
// 		if largest != i {
// 			swap(chas, largest, i)
// 		} else {
// 			break
// 		}
// 		i = largest
// 		left = i*2 + 1
// 		right = i*2 + 21
// 	}
// }

// func swap(chas []byte, index1 int, index2 int) {
// 	tmp := chas[index1]
// 	chas[index1] = chas[index2]
// 	chas[index2] = tmp
// }

// func myAtoi(s string) int {
// 	sli := s[:]
// 	i := 0
// 	for ; i < len(sli); i++ {
// 		if sli[i] != ' ' {
// 			break
// 		}
// 	}
// 	sli = sli[i:]
// 	// fmt.Println(sli)
// 	post := true
// 	if len(sli) != 0 && (sli[0] == '-' || sli[0] == '+') {
// 		if sli[0] == '-' {
// 			post = false
// 		}
// 		sli = sli[1:]
// 	}

// 	i = 0
// 	for ; i < len(sli); i++ {
// 		if sli[i] != '0' {
// 			break
// 		}
// 	}
// 	sli = sli[i:]

// 	minq := math.MinInt32 / 10
// 	minr := math.MinInt32 % 10
// 	res := 0
// 	for i := 0; i < len(sli); i++ {
// 		k, err := strconv.ParseInt(string(sli[i]), 10, 32)
// 		if err != nil {
// 			break
// 		}
// 		k = 0 - k
// 		if res < minq || res == minq && int(k) < minr {
// 			if post {
// 				return math.MaxInt32
// 			} else {
// 				return math.MinInt32
// 			}
// 		}
// 		res = res*10 + int(k)
// 	}
// 	if post {
// 		if res == math.MinInt32 {
// 			return math.MaxInt32
// 		}
// 		return -1 * res
// 	}
// 	return res

// }

// func CheckPermutation(s1 string, s2 string) bool {
// 	if len(s1) == 0 && len(s2) ==0{
// 		return true
// 	}
// 	nmap := make(map[byte]int)
// 	for i:=0;i<len(s1);i++{
// 		nmap[s1[i]]++
// 	}
// 	for i,v := range s2{
// 		if v,ok := nmap[v];!ok || v==0{
// 			return false
// 		}else{
// 			nmap[v]--
// 		}
// 	}
// 	return true
// }
// func totalNQueens(n int) (ans int) {
// 	if n < 1 {
// 		return 0
// 	}
// 	upperLim := (1 << n) - 1
// 	var process func(upperLim int, colLim int, leftDiaLim int, rightDiaLim int) int
// 	process = func(upperLim int, colLim int, leftDiaLim int, rightDiaLim int) int {
// 		if colLim == upperLim {
// 			return 1
// 		}

// 		pos := 0
// 		mostRightOne := 0
// 		pos = upperLim & (^(colLim | leftDiaLim | rightDiaLim))
// 		res := 0
// 		for pos != 0 {
// 			mostRightOne = pos & (^pos + 1)
// 			pos = pos - mostRightOne
// 			ans += process(upperLim, colLim|mostRightOne, (leftDiaLim|mostRightOne)<<1, (rightDiaLim|mostRightOne)>>1)
// 		}
// 		return res
// 	}
// 	process(upperLim, 0, 0, 0)
// 	return
// }

// func jump(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	next := 0
// 	cut := 0
// 	jump := 0
// 	for i := 0; i < len(nums); i++ {
// 		if cut < i {
// 			cut = next
// 			jump++
// 		}
// 		next = max(next, i+nums[i])
// 		if next == len(nums)-1 {
// 			break
// 		}
// 	}

// 	return jump
// }

// func totalNQueens(n int) (ans int) {
//     var solve func(row, columns, diagonals1, diagonals2 int)
//     solve = func(row, columns, diagonals1, diagonals2 int) {
//         if row == n {
//             ans++
//             return
//         }
//         availablePositions := (1<<n - 1) &^ (columns | diagonals1 | diagonals2)
//         for availablePositions > 0 {
//             position := availablePositions & -availablePositions
//             solve(row+1, columns|position, (diagonals1|position)<<1, (diagonals2|position)>>1)
//             availablePositions &^= position // 移除该比特位
//         }
//     }
//     solve(0, 0, 0, 0)
//     return
// }

// func canJump(nums []int) bool {
// 	if len(nums) == 0 {
// 		return true
// 	}
// 	next := 0
// 	cut := 0

// 	for i := 0; i < len(nums); i++ {
// 		if cut < i {
// 			cut = next
// 		}
// 		next = max(next, i+nums[i])
// 	}
// 	if next >= len(nums) {
// 		return true
// 	}
// 	return false
// }

// func translateNum(num int) int {
// 	if num == 0 {
// 		return 0
// 	}
// 	nums := make([]int, 0)
// 	for num != 0 {
// 		nums = append([]int{num % 10}, nums...)
// 		num = num / 10
// 	}
// 	f := make([]int, len(nums))
// 	f[0] = 1
// 	res := 0
// 	for i := 1; i < len(nums); i++ {
// 		if nums[i-1] * 10 + nums[i] <= 25{
// 			f[i] = f[i-1]+1
// 		}else{
// 			f[i] = f[i-1]
// 		}

// 		if i-2 >= 0 && nums[i-1]*10+nums[i] <= 25 {
// 			f[i] = max(f[i], f[i-1]+1)
// 		}
// 		if res < f[i] {
// 			res = f[i]
// 		}
// 	}
// 	return res
// }

// if len(s1)+len(s2) != len(s3) {
// 	return false
// }
// dp := make([][]bool, len(s1)+1)
// for i := 0; i < len(dp); i++ {
// 	dp[i] = make([]bool, len(s2)+1)
// }
// if len(s3) == 0{
// 	dp[0][0] = true
// }

// for i := 1; i < len(dp); i++ {
// 	if s1[i-1] != s3[i-1] {
// 	 break
// 	}
// 	  dp[i][0] = true
// }
// for i := 1; i < len(dp[0]); i++ {
// 	if s2[i-1] != s3[i-1] {
// 		break
// 	}
// 	dp[0][i] = true
// }
// for i := 1; i < len(dp); i++ {
// 	for j := 1; j < len(dp[0]); j++ {
// 		if dp[i-1][j] && s1[i-1] == s3[i+j-1] || dp[i][j-1] && s2[j-1] == s3[i+j-1] {
// 			dp[i][j] = true
// 		}
// 	}
// }

// func calculateMinimumHP(dungeon [][]int) int {
// 	if len(dungeon) == 0 || len(dungeon[0])==0{
// 		return 0
// 	}
// 	dp := make([][]int,len(dungeon))
// 	for i:=0;i<len(dungeon);i++{
// 		dp[i] = make([]int,len(dungeon[0]))
// 	}
// 	m,n := len(dungeon),len(dungeon[0])
// 	if dungeon[m-1][n-1] < 0{
// 		dp[m-1][n-1] = -1 * dungeon[m-1][n-1] + 1
// 	}else{
// 		dp[m-1][n-1] = 1
// 	}

// 	for i:=n-2;i>=0;i--{
// 		dp[m-1][i] = max(dp[m-1][i+1]-dungeon[m-1][i]),1)
// 	}
// 	for i:=m-2;i>=0;i--{
// 		dp[i][n-1] = max(dp[i+1][n-1]-dungeon[i][n-1],1)
// 		for j:=n-2;i>=0;j--{
// 			right := max(dp[i][j+1]-dungeon[i][j],1)
// 			down := max(dp[i+1][j] - dungeon[i][j],1)
// 			dp[i][j] = min(right,left)
// 		}
// 	}
// 	return dp[0][0]
// }
// func isInterleave(s1 string, s2 string, s3 string) bool {
// 	if len(s1)+len(s2) != len(s3) {
// 		return false
// 	}
// 	dp := make([]bool, len(s2)+1)

//     if len(s3) == 0{
//         dp[0] = true
//     }

// 	for i := 1; i < len(dp); i++ {
// 		if s2[i-1] != s3[i-1] {
//          break
// 		}
//         dp[i] = true
// 	}

// 	for i := 1; i < len(dp); i++ {
// 		for j := 1; j < len(dp[0]); j++ {
// 			if dp[j-1] && s1[i-1] == s3[i+j-1] || dp[j] && s2[j-1] == s3[i+j-1] {
// 				dp[j] = true
// 			}
// 		}
// 	}
// 	return dp[len(dp[0])-1]
// }

// func minDistance(word1 string, word2 string) int {
// 	if len(word1) == 0 && len(word2) == 0 {
// 		return 0
// 	}
// 	dp := make([][]int, len(word1)+1)
// 	for i := 0; i < len(dp); i++ {
// 		dp[i] = make([]int, len(word2)+1)
// 	}
// 	for i := 1; i < len(dp); i++ {
// 		dp[i][0] = i
// 	}
// 	for i := 1; i < len(dp[0]); i++ {
// 		dp[0][i] = i
// 	}
// 	for i := 1; i < len(dp); i++ {
// 		for j := 1; j < len(dp[0]); j++ {
// 			if word1[i-1] == word2[j-1] {
// 				dp[i][j] = dp[i-1][j-1]
// 			} else {
// 				dp[i][j] = dp[i-1][j-1] + 1
// 			}
// 			dp[i][j] = min(dp[i][j], min(dp[i-1][j]+1, dp[i][j-1]+1))
// 		}
// 	}
// 	return dp[len(dp)-1][len(dp[0])-1]
// }

// func mostEOR(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	dp := make([]int, len(nums))
// 	nmap := make(map[int]int)
// 	if nums[0] == 0 {
// 		dp[0] = 1
// 	}

// 	nmap[0] = -1
// 	nmap[nums[0]] = 0
// 	eor := 0
// 	for i := 1; i < len(nums); i++ {
// 		eor ^= nums[i]
// 		if v, ok := nmap[eor]; ok {
// 			if v == -1 {
// 				dp[i] = 1
// 			} else {
// 				dp[i] = dp[v] + 1
// 			}
// 		}
// 		dp[i] = max(dp[i], dp[i-1])
// 		nmap[eor] = i
// 	}
// 	return dp[len(nums)-1]
// }

// func xorOperation(n int, start int) int {
// 	if n == 0 {
// 		return 0
// 	}
// 	nums := make([]int, 0)
// 	for i := 0; i < n; i++ {
// 		nums[i] = start + i*2
// 	}
// 	res := nums[0]
// 	for i := 1; i < n; i++ {
// 		res ^= nums[i]
// 	}
// 	return res
// }

// func longestCommonSubpath(n int, paths [][]int) int {
// 	if len(paths) == 0 || len(paths[0]) == 0 {
// 		return 0
// 	}

// 	for len(paths) != 1 && len(paths) != 0 {
// 		res := lcst2(paths[0], paths[len(paths)-1])
// 		paths = paths[1 : len(paths)-1]
// 		if res == nil {
// 			continue
// 		}
// 		paths = append(paths, res)
// 	}
// 	if len(paths) == 0 {
// 		return 0
// 	}
// 	return len(paths[0])
// }
// func lcst2(nums1 []int, nums2 []int) []int {
// 	if len(nums1) == 0 || len(nums2) == 0 {
// 		return nil
// 	}
// 	maxvalue := 0
// 	cut := 0
// 	row, col := 0, len(nums2)-1
// 	temp := 0
// 	for row < len(nums1) {
// 		i := row
// 		j := col
// 		for i < len(nums1) && j < len(nums2) {
// 			if nums1[i] == nums2[j] {
// 				k := 1 + cut
// 				if maxvalue < k {
// 					maxvalue = k
// 					temp = j
// 				}
// 				cut = 1 + cut
// 			} else {
// 				cut = 0
// 			}
// 			i++
// 			j++
// 		}
// 		if col > 0 {
// 			col--
// 		} else {
// 			row++
// 		}
// 	}
// 	fmt.Println(cut, maxvalue)
// 	res := make([]int, maxvalue)
// 	for i := 0; i < maxvalue; i++ {
// 		res = append(res, nums2[temp-i])
// 	}
// 	return res
// }

// func longestCommonSubsequence(text1 string, text2 string) int {
// 	if len(text1) == 0 || len(text2) == 0 {
// 		return 0
// 	}
// 	dp := make([][]int, len(text1)+1)
// 	for i := 0; i < len(text2); i++ {
// 		dp[i] = make([]int, len(text2)+1)
// 	}

// 	for i := 1; i < len(dp); i++ {
// 		for j := 1; j < len(dp[0]); j++ {
// 			if text1[i-1] == text2[j-1] {
// 				dp[i][j] = 1 + dp[i-1][j-1]

// 			}
// 			dp[i][j] = max(dp[i][j], max(dp[i-1][j], dp[i][j-1]))
// 		}
// 	}
// 	return dp[len(dp)-1][len(dp[0])-1]
// }

// func lengthOfLIS(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	stack := make([]int, 0)
// 	stack = append(stack, nums[0])
// 	for i := 1; i < len(nums); i++ {
// 		fmt.Println(stack)
// 		if nums[i] > stack[len(stack)-1] {
// 			stack = append(stack, nums[i])
// 		} else {
// 			l, r := 0, len(stack)-1
// 			for l+1 < r {
// 				mid := (l + r) / 2
// 				if stack[mid] < nums[i] {
// 					l = mid
// 				} else {
// 					r = mid
// 				}
// 			}
// 			if stack[l] < nums[i] {
// 				stack[l+1] = nums[i]
// 			} else {
// 				stack[l] = nums[i]
// 			}
// 		}
// 	}
// 	return len(stack)
// }

// func maxEnvelopes(envelopes [][]int) int {
// 	if len(envelopes) == 0 || len(envelopes[0]) == 0 {
// 		return 0
// 	}
// 	sort.Slice(envelopes, func(i, j int) bool {
// 		return envelopes[i][0] < envelopes[j][0] || envelopes[i][0] == envelopes[j][0] && envelopes[i][1] < envelopes[j][1]
// 	})
// 	end := make([]int, len(envelopes))
// 	end[0] = envelopes[0][1]
// 	l, r := 0, len(envelopes)
// 	right := 0
// 	m := 0
// 	for i := 1; i < len(envelopes); i++ {
// 		l, r = 0, right
// 		for l <= r {
// 			m = (l + r) / 2
// 			if envelopes[i][1] > end[m] {
// 				l = m + 1
// 			} else {
// 				r = m - 1
// 			}
// 		}
// 		right = max(right, l)
// 		end[l] = envelopes[i][1]

// 	}
// 	return right + 1
// }

// func maxEnvelopes(envelopes [][]int) int {
// 	if len(envelopes) == 0 || len(envelopes[0]) == 0 {
// 		return 0
// 	}
// 	sort.Slice(envelopes, func(i, j int) bool {
// 		return envelopes[i][0] < envelopes[j][0] || envelopes[i][0] == envelopes[j][0] && envelopes[i][1] < envelopes[j][1]
// 	})
// 	fmt.Println(envelopes)
// 	f := make([]int, len(envelopes))
// 	f[0] = 1
// 	for i := 0; i < len(envelopes); i++ {
// 		f[i] = 1
// 		for j := i - 1; j >= 0; j-- {
// 			if envelopes[i][0] > envelopes[j][0] && envelopes[i][1] > envelopes[j][1] {
// 				f[i] = max(f[i], f[j]+1)
// 			}
// 		}
// 	}
// 	res := 0
// 	for _, v := range f {
// 		if res < v {
// 			res = v
// 		}
// 	}
// 	fmt.Println(f)
// 	return res
// }

// func findSubsequences(nums []int) [][]int {
// 	if len(nums) == 0 {
// 		return nil
// 	}
// 	f := make([]int, len(nums))
// 	fmt.Println(nums)
// 	result := make([][]int,0)
// 	for i := 1; i < len(nums); i++ {
// 		f[i] = 1
// 		for j := i - 1; j >= 0; j-- {
// 			if nums[i]-nums[j] == 1 {
// 				f[i]++
// 			} else {
// 				break
// 			}
// 		}
// 	}
// 	for i,v := range f{
// 		if v > 1{
// 			res := make([]int,v)

// 		}
// 	}
// }
// func longestConsecutive(nums []int) int {

// 	res := 0
// 	for _, v := range f {
// 		if res < v {
// 			res = v
// 		}
// 	}
// 	fmt.Println(f)
// 	return res
// }

// func longestConsecutive(nums []int) int {
// 	if len(nums) == 0{
// 		return 0
// 	}
// 	f := make([]int,0)
// 	sort.Ints(nums)
// 	f[0] = 1
// 	for i:=1;i<len(nums);i++{
// 		f[i] = 1
// 		if nums[i] - nums[i-1] == 1{
// 			f[i] = f[i] + f[i-1]
// 		}
// 	}
// 	res := 0
// 	for _,v := range nums{
// 		if res < v{
// 			res = v
// 		}
// 	}
// 	return res
// }

// func findNumberOfLIS(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	l, res := 0, 0
// 	f := make([]int, len(nums)+1)

// 	for i := 0; i < len(nums); i++ {
// 		f[i] = 1
// 		k := 0
// 		for j := 0; j < i; j++ {
// 			if nums[j] < nums[i] {
// 				if f[j]+1 == f[i] {
// 					k++
// 				} else if f[j]+1 > f[i] {
// 					f[i] = f[j] + 1
// 					l = f[i]
// 					res = 0
// 					k = 0
// 				}
// 			}
// 		}
// 		if f[i] == l {
// 			res += 1 + k
// 		}
// 	}
// 	return res
// }

// func findNumberOfLIS(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	stack := make([]int, 0)
// 	l, v := 1, 1
// 	for i := 0; i < len(nums); i++ {
// 		if len(stack) == 0 || nums[i] > stack[len(stack)-1] {
// 			stack = append(stack, nums[i])
// 		} else {
// 			left, right := 0, len(stack)
// 			for left < right {
// 				mid := left + (right-left)/2
// 				if nums[i] <= stack[mid] {
// 					right = mid
// 				} else if nums[i] > stack[mid] {
// 					left = mid + 1
// 				}
// 			}
// 			stack[left] = nums[i]
// 			stack = stack[:left+1]
// 		}
// 		if len(stack) == l {
// 			v++
// 		} else if len(stack) > l {
// 			l = len(stack)
// 			v = 1
// 		}
// 	}
// 	return v
// }

// func lengthOfLIS(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	f := make([]int, len(nums)+1)
// 	f[0] = 0
// 	for i := 0; i < len(nums); i++ {
// 		f[i] = 1
// 		for j := 0; j < i; j++ {
// 			if nums[j] < nums[i] {
// 				f[i] = max(f[i], f[j]+1)
// 			}
// 		}
// 	}
// 	res := 0
// 	fmt.Println(f)
// 	for _, v := range f {
// 		if res < v {
// 			res = v
// 		}
// 	}
// 	return res
// }

// func maxCoins(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	dp := make([][]int, len(nums)+2)
// 	for i := 0; i < len(dp); i++ {
// 		dp[i] = make([]int, len(nums)+2)
// 	}
// 	nums = append([]int{1}, nums...)
// 	nums = append(nums, 1)
// 	for i := 1; i < len(dp)-1; i++ {
// 		dp[i][i] = nums[i] * nums[i-1] * nums[i+1]
// 	}
// 	for L := len(nums) - 2; L >= 1; L-- {
// 		for R := L + 1; R <= len(nums)-2; R++ {
// 			finalL := nums[L]*nums[L-1]*nums[R+1] + dp[L+1][R]
// 			finalR := nums[R]*nums[L-1]*nums[R+1] + dp[L][R-1]
// 			m := max(finalL, finalR)
// 			for i := L + 1; i < R; i++ {
// 				m = max(m, nums[L-1]*nums[i]*nums[R+1]+dp[L][i-1]+dp[i+1][R])
// 			}
// 			dp[L][R] = m
// 		}
// 	}
// 	return dp[1][len(nums)-2]
// }

// func change(amount int, coins []int) int {
// 	if len(coins) == 0 {
// 		return 0
// 	}
// 	f := make([]int, amount+1)
// 	f[0] = 1
// 	for i := 1; coins[0]*i <= amount; i++ {
// 		f[coins[0]*i] = 1
// 	}
// 	for i := 0; i < len(coins); i++ {
// 		for j := 1; j <= amount; j++ {
// 			f[j] += f[j-1]
// 			if j-coins[i] >= 0 {
// 				f[j] += f[j-coins[i]]
// 			}
// 		}
// 	}
// 	return f[amount]
// }

// func numWaterBottles(numBottles int, numExchange int) int {
// 	sum := numBottles
// 	k := 0
// 	for (numBottles + k)/numExchange != 0 {
// 		if (numBottles + k)%numExchange != 0 {
// 			sum += numBottles/numExchange
// 			k += numBottles % numExchange
// 			numBottles = numBottles / numExchange
// 		} else {
// 			sum += (numBottles + k)/ numExchange
// 			k = 0
// 		}
// 	}
// 	return sum
// }

// func minCount(coins []int) int {
// 	if len(coins) == 0{
// 		return 0
// 	}
// 	sum := 0
// 	for i:=0;i<len(coins);i++{
// 		if coins[i] % 2 == 0{
// 			sum += coins[i] / 2
// 		}else{
// 			sum += coins[i] / 2 + 1
// 		}
// 	}
// 	return sum
// }

// func waysToChange(n int) int {
// 	nums := []int{1, 5, 10, 25}
// 	dp := make([]int, n+1)
// 	dp[0] = 1
// 	for i := 1; nums[0]*i <= n; i++ {
// 		dp[nums[0]*i] = 1
// 	}
// 	for i := 0; i < len(nums); i++ {
// 		for j := 1; j <= n; j++ {
// 			if j-nums[i] >= 0 {
// 				dp[j] += dp[j-nums[i]]
// 			}

// 		}
// 	}
// 	return dp[n]
// }

// func coinChange(coins []int, amount int) int {
// 	if len(coins) == 0 {
// 		return 0
// 	}
// 	f := make([]int, amount+1)
// 	for i := 0; i <= amount; i++ {
// 		f[i] = amount + 1
// 	}
// 	f[0] = 0
// 	for i := 1; i <= amount; i++ {
// 		for j := 0; j < len(coins); j++ {
// 			if i-coins[j] >= 0 {
// 				f[i] = min(f[i], f[i-coins[j]]+1)
// 			}
// 		}
// 	}
// 	if f[amount] > amount {
// 		return -1
// 	}
// 	return f[amount]
// }

// func minPathSum(grid [][]int) int {
//     if len(grid) == 0 || len(grid[0]) == 0{
//         return 0
//     }
//     for i:=1;i<len(grid);i++{
//         grid[i][0] = grid[i][0] + grid[i-1][0]
//     }
//     for i:=1;i<len(grid[0]);i++{
//         grid[0][i] = grid[0][i] + grid[0][i-1]
//     }
//     for i:=1;i<len(grid);i++{
//         for j:=1;j<len(grid[0]);j++{
//             grid[i][j] = min(grid[i-1][j],grid[i][j-1]) + grid[i][j]
//         }
//     }
//     return grid[len(grid)-1][len(grid[0])-1]
// }
// func isCousins(root *TreeNode, x int, y int) bool {
// 	if root == nil {
// 		return true
// 	}
// 	nodes := make([]*TreeNode, 0)
// 	nodes = append(nodes, root)

// 	for len(nodes) > 0 {
// 		l := len(nodes)
// 		flag := 0
// 		for i := 0; i < l; i++ {
// 			node := nodes[0]
// 			nodes = nodes[1:]
// 			if node.Left != nil {
// 				nodes = append(nodes, node.Left)
// 				if node.Left.Val == x || node.Left.Val == y {
// 					flag++
// 				}
// 			}
// 			if node.Right != nil {
// 				nodes = append(nodes, node.Right)
// 				if node.Right.Val == x || node.Right.Val == y {
// 					flag++
// 					if node.Left != nil && (node.Left.Val == x || node.Left.Val == y) {
// 						return false
// 					}
// 				}
// 			}
// 			if flag == 2 {
// 				return true
// 			}
// 		}
// 	}
// 	return false
// }

// func findTarget(root *TreeNode, k int) bool {
// 	findmap := make(map[int]bool, 0)
// 	var reverseFind func(root *TreeNode)
// 	reverseFind = func(root *TreeNode) {
// 		if root == nil {
// 			return
// 		}
// 		findmap[root.Val] = true
// 		reverseFind(root.Left)
// 		reverseFind(root.Right)
// 	}
// 	reverseFind(root)
// 	for i, _ := range findmap {
// 		if _, ok := findmap[k-i]; ok {
// 			return true
// 		}
// 	}
// 	return false
// }

// func countNodes(root *TreeNode) int {
// 	if root == nil {
// 		return 0
// 	}
// 	return bs(root,1,mostLeftLevel(root,1))
// }
// func bs(head *TreeNode, l int, h int) int {
// 	if l == h {
// 		return 1
// 	}
// 	if mostLeftLevel(head.Right, l+1) == h {
// 		return (1 << (h - l)) + bs(head.Right, 1+l, h)
// 	} else {
// 		return (1 << (h - l - 1)) + bs(head.Left, l+1, h)
// 	}
// }
// func mostLeftLevel(head *TreeNode, level int) int {
// 	for head != nil {
// 		level++
// 		head = head.Left
// 	}
// 	return level - 1
// }
// func countNodes(root *TreeNode) int {
// 	if root == nil {
// 		return 0
// 	}
// 	return bs(head)
// }
// func bs(head *TreeNode, l int, h int) int {
// 	if l == h {
// 		return l
// 	}
// 	if mostLeftLevel(head.Right, l+1) == h {
// 		return (1 << (h - l)) + bs(head.Right, 1+l, h)
// 	} else {
// 		return (1 << (h - l - 1)) + bs(head.Left, l+1, h)
// 	}
// }
// func mostLeftLevel(head *TreeNode, level int) int {
// 	for head != nil {
// 		level++
// 		head = head.Left
// 	}
// 	return level - 1
// }

// func generateTrees(n int) []*TreeNode {
//     if n == 0{
//         return nil
//     }
//     result := make([]*TreeNode,0)

// }
// func numTrees(n int) int {
// 	if n <= 1 {
// 		return n
// 	}
// 	result := 0
// 	f := make([]int, n+1)
// 	f[0] = 0
// 	f[1] = 1
// 	for i := 2; i <= n; i++ {
// 		res := 0
// 		for j := 1; j <= i; j++ {
// 			if j == 1 || j == i {
// 				res += f[i-1]

// 			} else {
// 				res = res + f[j-1]*f[i-j]
// 			}
// 			// fmt.Println("i", i, res)
// 		}
// 		// fmt.Println(i, res)
// 		f[i] = res
// 		result += res
// 	}
// 	return f[n]
// }

// func buildTree(preorder []int, inorder []int) *TreeNode {

// 	inmap := make(map[int]int)
// 	for i := 0; i < len(inorder); i++ {
// 		inmap[inorder[i]] = i
// 	}
// 	var reverseBuild func(preorder []int, inorder []int) *TreeNode
// 	reverseBuild = func(preorder []int, inorder []int) *TreeNode {
// 		if len(preorder) == 0 || len(inorder) == 0 {
// 			return nil
// 		}
// 		root := &TreeNode{
// 			Val: preorder[0],
// 		}
// 		mid := inmap[preorder[0]]
// 		root.Left = buildTree(preorder[1:mid+1], inorder[:mid])
// 		root.Right = buildTree(preorder[mid+1:], inorder[mid+1:])
// 		return root
// 	}
// 	root := reverseBuild(preorder, inorder)
// 	return root
// }

// type newprocess struct{
//     height int
//     maxHeight int
// }
// func Process(root *TreeNode) int{
//     if root == nil{
//         return 0
//     }
//     var reverseProcess func(root *TreeNode) newprocess
//     reverseProcess = func(root *TreeNode) newprocess{
//         if root == nil{
//             return newprocess{0,0}
//         }
//         left := reverseProcess(root.Left)
//         right := reverseProcess(root.Right)
//         height := max(left.height,right.height) + 1
//         maxHeight := max(left.height+right.height+1,max(left.maxHeight,right.maxHeight))
//         return newprocess{height,maxHeight}
//     }
//    res :=  reverseProcess(root)
//    return res.maxHeight
// }

// func largestValues(root *TreeNode) []int {
// 	if root == nil {
// 		return nil
// 	}
// 	result := make([]int, 0)
// 	nodes := make([]*TreeNode, 0)
// 	nodes = append(nodes, root)
// 	for len(nodes) > 0 {
// 		l := len(nodes)
// 		res := math.MinInt64
// 		for i := 0; i < l; i++ {
// 			node := nodes[0]
// 			nodes = nodes[1:]
// 			if node.Val > res {
// 				res = node.Val
// 			}
// 			if node.Left != nil {
// 				nodes = append(nodes, node.Left)
// 			}
// 			if node.Right != nil {
// 				nodes = append(nodes, node.Right)
// 			}
// 		}
// 		result = append(result, res)
// 	}
// 	return result
// }

// type Node struct {
// 	Val    int
// 	Left   *Node
// 	Right  *Node
// 	Parent *Node
// }

// func inorderSuccessor(node *Node) *Node {
// 	if node == nil {
// 		return nil
// 	}
// 	//第一种情况有右边节点那么就是右节点的最左节点
// 	if node.Right != nil {
// 		root := node.Right
// 		for root.Left != nil {
// 			root = root.Left
// 		}
// 		return root
// 	}

// 	head := node.Parent
// 	if head.Left == node {
// 		return head
// 	}
// 	cur := head.Parent
// 	for cur != nil && cur.Left != head {
// 		head = cur
// 		cur = cur.Parent
// 	}
// 	return cur
// }

// type CommonAddr struct {
// 	head *TreeNode
// 	p    *TreeNode
// 	q    *TreeNode
// }

// func lowestCommonAncestor(p *Node, q *Node) *Node {
// 	if p == nil || q == nil {
// 		return nil
// 	}
// 	pmap := make(map[*Node]bool)
// 	cur := p
// 	for cur != nil {
// 		pmap[cur] = true
// 		cur = cur.Parent
// 	}
// 	head := q
// 	for head != nil {
// 		if _, ok := pmap[head]; ok {
// 			return head
// 		}
// 		head = head.Parent
// 	}
// 	return nil
// }

// func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
// 	if root == nil {
// 		return nil
// 	}
//    left :=  lowestCommonAncestor(root.Left,p,q)
//     right := lowestCommonAncestor(root.Left,p,q)
//     if left != nil && right != nil{
//         return root
//     }
//     if left != nil {
//         return left
//     }
//     if right != nil {
//         return right
//     }
//     return nil
// }

// func balanceBST(root *TreeNode) *TreeNode {
// 	if root == nil {
// 		return nil
// 	}
// 	vals := make([]int, 0)
// 	var reverseBalance func(*TreeNode)
// 	reverseBalance = func(root *TreeNode) {
// 		if root == nil {
// 			return
// 		}
// 		reverseBalance(root.Left)
// 		vals = append(vals, root.Val)
// 		reverseBalance(root.Right)

// 	}
// 	reverseBalance(root)

// 	var NewSeekBalanceTree func(nums []int) *TreeNode
// 	NewSeekBalanceTree = func(nums []int) *TreeNode {
// 		if len(nums) == 0 {
// 			return nil
// 		} else if len(nums) == 1 {
// 			return &TreeNode{
// 				Val: nums[0],
// 			}
// 		}
// 		root := &TreeNode{Val: nums[len(nums)/2]}
// 		root.Left = NewSeekBalanceTree(nums[:len(nums)/2])
// 		root.Right = NewSeekBalanceTree(nums[len(nums)/2+1:])
// 		return root
// 	}
// 	res := NewSeekBalanceTree(vals)
// 	return res

// }

// func verifyPostorder(postorder []int) *TreeNode {
//     if len(postorder) == 0{
//         return nil
//     }else if len(postorder) == 1{
//         return &TreeNode{
//             Val:postorder[0],
//         }
//     }
//     root := &TreeNode{
//         Val:postorder[len(postorder)-1],
//     }

//     postorder = postorder[:len(postorder)-1]
//     mid := -1
//     for i:=len(postorder)-1;i>=0;i--{
//         if postorder[i] <= root.Val{
//             mid = i
//             break
//         }
//     }
//     for i:=0;i<mid;i++{
//         if postorder[i] >= root.Val{
//             return false
//         }
//     }

//     root.Left = verifyPostorder(postorder[:mid+1])
//     root.Right = verifyPostorder(postorder[mid+1:])
//     return root
// }
// type Balance struct {
// 	height int
// 	ok     bool
// }

// func isBalanced(root *TreeNode) bool {
// 	if root == nil {
// 		return false
// 	}
// 	var reverseIsBalance func(root *TreeNode) Balance
// 	reverseIsBalance = func(root *TreeNode) Balance {
// 		if root == nil {
// 			return Balance{
// 				height: 0,
// 				ok:     true,
// 			}
// 		}
//         left := reverseIsBalance(root.Left)
//         right := reverseIsBalance(root.Right)
//         if !left.ok || !right.ok || left.height-right.height > 1 || right.height - left.height > 1{
//             return Balance{
//                 ok:false,
//             }
//         }
//         return Balance{
//             height: max(left.height,right.height)+1,
//         }

// 	}
//     k := reverseIsBalance(root)
//     return k.ok

// }

// func strStr(haystack, needle string) int {
//     n, m := len(haystack), len(needle)
//     if m == 0 {
//         return 0
//     }
//     pi := make([]int, m)
//     for i := 1 ; i < m; i++ {
//         for j:=0;j > 0 && needle[i] != needle[j]; {
//             j = pi[j-1]
//         }
//         if needle[i] == needle[j] {
//             j++
//         }
//         pi[i] = j
//     }
//     for i, j := 0, 0; i < n; i++ {
//         for j > 0 && haystack[i] != needle[j] {
//             j = pi[j-1]
//         }
//         if haystack[i] == needle[j] {
//             j++
//         }
//         if j == m {
//             return i - m + 1
//         }
//     }
//     return -1
// }

// func recoverTree(root *TreeNode) {
// 	if root == nil {
// 		return
// 	}
// 	result := make([]*TreeNode, 0)
// 	var MiddleRecover func(root *TreeNode)
// 	MiddleRecover = func(root *TreeNode) {
// 		if root == nil {
// 			return
// 		}
// 		MiddleRecover(root.Left)
// 		result = append(result, root)
// 		MiddleRecover(root.Right)
// 	}
// 	MiddleRecover(root)
// 	var l, r *TreeNode
// 	ok := false
// 	for i := 0; i < len(result)-1; i++ {
// 		if result[i].Val > result[i+1].Val {
// 			if !ok {
// 				l, r = result[i], result[i+1]
// 				ok = !ok
// 			} else {
// 				r = result[i+1]
// 			}
// 		}
// 	}
// 	r.Val, l.Val = l.Val, r.Val
// }

// func zigzagLevelOrder(root *TreeNode) [][]int {
//     if root == nil{
//         return nil
//     }
//     result := make([][]int,0)
//     nodes := make([]*TreeNode,0)
//     nodes = append(nodes,root)
//     cut := true
//     for len(nodes) > 0{
//         l := len(nodes)
//         res := make([]int,0)
//         for i:=0;i<l;i++{
//             node := nodes[0]
//             nodes = nodes[1:]
//             res = append(res,node.Val)
//             if node.Left != nil{
//                 nodes = append(nodes,node.Left)
//             }
//             if node.Right != nil{
//                 nodes = append(nodes,node.Right)
//             }
//         }
//         if cut {
//             result = append(result,res)
//         }else{
//             for i:=0;i<len(res)/2;i++{
//                 res[i],res[len(res)-i-1] = res[len(res)-i-1],res[i]
//             }
//             result = append(result,res)
//         }
//         cut = !cut
//     }
//     return result
// }
// type Record struct {
// 	l int
// 	r int
// }

// func bstTopoSize2(head *TreeNode) int {
// 	nodemap := make(map[*TreeNode]Record)
// 	return posOrder(head, nodemap)
// }

// func posOrder(root *TreeNode, nodemap map[*TreeNode]Record) int {
// 	if root == nil {
// 		return 0
// 	}
// 	ls := posOrder(root.Left, nodemap)
// 	rs := posOrder(root.Right, nodemap)

// 	modifyMap(root.Left, root.Val, nodemap, true)   //true表示搜索左分支的右分支
// 	modifyMap(root.Right, root.Val, nodemap, false) //false表示搜索右分支的左分支
// 	recode := Record{}
// 	recodel, ok := nodemap[root.Left]
// 	if ok {
// 		recode.l = recodel.l + recodel.r + 1
// 	}
// 	recoder, ok := nodemap[root.Right]
// 	if ok {
// 		recode.l = recoder.l + recoder.r + 1
// 	}
// 	nodemap[root] = recode
// 	return max(recode.l+recode.r+1, max(ls, rs))
// }

// func modifyMap(root *TreeNode, val int, nodemap map[*TreeNode]Record, s bool) int {
// 	if _, ok := nodemap[root]; !ok || root == nil {
// 		return 0
// 	}
// 	record := nodemap[root]
// 	if s && root.Val > val || !s && root.Val < val { //如果这个节点不满足则返回用于删除
// 		delete(nodemap, root)
// 		return record.l + record.r + 1
// 	} else {
// 		minus := 0
// 		if s {
// 			minus = modifyMap(root.Right, val, nodemap, s)
// 			record.r -= minus
// 		} else {
// 			minus = modifyMap(root.Left, val, nodemap, s)
// 			record.l -= minus
// 		}

// 		nodemap[root] = record
// 		return minus
// 	}
// }

// type validBST struct {
// 	minVal int
// 	maxVal int
// 	ok     bool
// }

// func isValidBST(root *TreeNode) bool {
// 	if root == nil {
// 		return false
// 	}
// 	var reverseIsValidBST func(root *TreeNode) validBST
// 	reverseIsValidBST = func(root *TreeNode) validBST {
// 		if root == nil {
// 			return validBST{
// 				minVal: math.MaxInt32,
// 				maxVal: math.MinInt32,
// 				ok:     true,
// 			}
// 		}
// 		left := reverseIsValidBST(root.Left)
// 		right := reverseIsValidBST(root.Right)
// 		if !left.ok || !right.ok {
// 			return validBST{ok: false}
// 		}
// 		if root.Val < left.maxVal || root.Val > right.minVal {
// 			return validBST{ok: false}
// 		}
// 		minval := min(root.Val, min(left.minVal, right.minVal))
// 		maxval := max(root.Val, max(left.maxVal, right.maxVal))
// 		return validBST{
// 			minVal: minval,
// 			maxVal: maxval,
// 			ok:     true,
// 		}
// 	}
// 	result := reverseIsValidBST(root)
// 	return result.ok
// }

// type lowancestor struct{
//     root *TreeNode
//     ok bool
// }
// func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
//     if root == nil{
//         return nil
//     }
//     left := lowestCommonAncestor(root.Left,p,q)
//     right := lowestCommonAncestor(root.Right,p,q)
//     if left == q && right == q{
//         return
//     }
// }

// func rangeSumBST(root *TreeNode, low int, high int) int {
//     if root == nil{
//         return 0
//     }
//     if root.Val >= high{
//         left := rangeSumBST(root.Left,low,high)
//         if root.Val == high{
//             return left + root.Val
//         }
//         return left
//     }
//     if root.Val <= low{
//         right := rangeSumBST(root.Right,low,high)
//         if root.Val == low{
//             return right + root.Val
//         }
//         return right
//     }
//     left := rangeSumBST(root.Left,low,high)
//     right := rangeSumBST(root.Right,low,high)
//     return root.Val + left + right
// }

// type Codec struct {
// 	res  string
// 	root *TreeNode
// }

// func Constructor() Codec {
// 	return Codec{
// 		res:  "",
// 		root: nil,
// 	}
// }

// // Serializes a tree to a single string.
// func (this *Codec) serialize(root *TreeNode) string {
// 	if root == nil {
// 		return "#!"
// 	}
// 	res := string(root.Val) + "!"
// 	nodes := make([]*TreeNode, 0)
// 	nodes = append(nodes, root)

// 	for len(nodes) >= 0 {
// 		node := nodes[0]
// 		nodes = nodes[1:]
// 		if node.Left != nil {
// 			res += string(node.Left.Val) + "!"
// 			nodes = append(nodes, node.Left)
// 		} else {
// 			res += "#!"
// 		}
// 		if node.Right != nil {
// 			res += string(node.Right.Val) + "!"
// 			nodes = append(nodes, node.Right)
// 		} else {
// 			res += "#!"
// 		}
// 	}
// 	return res
// }

// // Deserializes your encoded data to tree.
// func (this *Codec) deserialize(data string) *TreeNode {
// 	values := strings.Split(data, "!")
// 	index := 0
// 	root := Generatenode(values[index])
// 	index++
// 	if root == nil {
// 		this.root = nil
// 		return nil
// 	}
// 	nodes := make([]*TreeNode, 0)
// 	nodes = append(nodes, root)
// 	for len(nodes) != 0 {
// 		node := nodes[0]
// 		nodes = nodes[1:]
// 		node.Left = Generatenode(values[index])
// 		index++
// 		node.Right = Generatenode(values[index])
// 		index++
// 		if node.Left != nil {
// 			nodes = append(nodes, node.Left)
// 		}
// 		if node.Right != nil {
// 			nodes = append(nodes, node.Right)
// 		}
// 	}
// 	this.root = root
// 	return root
// }

// func Generatenode(val string) *TreeNode {
// 	if val == "#" {
// 		return nil
// 	} else {
// 		val, _ := strconv.ParseInt(val, 10, 32)
// 		return &TreeNode{
// 			Val: int(val),
// 		}
// 	}
// }

// func minDepth(root *TreeNode) int {
//     if root = nil{
//         return 0
//     }
//     left := minDepth(root.Left)
//     right := minDepth(root.Right)
//     if left < right{
//         return left +1
//     }
//     return right + 1
// }

// func postorderTraversal(root *TreeNode) []int {
//     if root == nil{
//         return nil
//     }
//     result := make([]int,0)
//     stack := make([]*TreeNode,0)
//     var lastVisit *TreeNode
//     for root != nil && len(stack) != 0{
//         for root != nil{
//             stack = append(stack,root)
//             root = root.Left
//         }

//         node := stack[len(stack)-1]
//         if node.Right == nil || node.Right == lastVisit{
//             stack = stack[:len(stack)-1]
//             result = append(result,node.Val)
//             lastVisit = node
//         }else{
//          root = node.Right
//         }
//     }
//     return result
// }
// func inorderTraversal(root *TreeNode) []int {
//     if root == nil{
//         return nil
//     }
//     result := make([]int,0)
//     stack := make([]*TreeNode,0)
//     for root != nil || len(stack) != 0{
//         for root !=nil{
//             stack = append(stack,root)
//             root = root.Left
//         }
//         node := stack[len(stack)-1]
//         stack = stack[:len(stack)-1]
//         result = append(result,node.Val)
//         root = node.Right
//     }
//     return result
// }
// func preorderTraversal(root *TreeNode) []int {
//     if root == nil{
//         return nil
//     }
//     result := make([]int,0)
//     stack := make([]*TreeNode,0)
//     for root != nil || len(stack) != 0{
//         for root != nil{
//             result = append(result,root.Val)
//             stack = append(stack,root)
//             root = root.Left
//         }
//         node := stack[len(stack-1)]
//         stack = stack[:len(stack)-1]
//         node = node.Right
//     }
//     return result
// }
// func preorderTraversal(root *TreeNode) []int {
//     if root == nil{
//         return nil
//     }
//     res := make([]int,0)
//     left := preorderTraversal(root.Left)
//     right := preorderTraversal(root.Right)
//     res = append(res,left...)
//     res = append(res,right...)
//     res = append(res,root.Val)
//     return res
// }
// func reorderList(head *ListNode) {
// 	if head == nil {
// 		return
// 	}
// 	slow := head
// 	fast := head
// 	for fast != nil && fast.Next != nil {
// 		slow = slow.Next
// 		fast = fast.Next.Next
// 	}
// 	righthead := slow.Next
// 	slow.Next = nil

// 	ordump := head
// 	head = head.Next
// 	rhead := reverseList(righthead)
// 	ok := false
// 	for head != nil && rhead != nil {
// 		if ok {
// 			ordump.Next = head
// 			head = head.Next
// 		} else {
// 			ordump.Next = rhead
// 			rhead = rhead.Next

// 		}
// 		ordump = ordump.Next
// 		ok = !ok
// 	}
// 	if head != nil {
// 		ordump.Next = head
// 	}
// 	if rhead != nil {
// 		ordump.Next = rhead
// 	}
// }

// func reverseList(head *ListNode) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	var pre *ListNode
// 	temp := head
// 	for temp != nil {
// 		node := temp.Next
// 		temp.Next = pre
// 		pre = temp
// 		temp = node
// 	}
// 	return pre
// }

// type Node struct {
// 	Val  int
// 	Next *Node
// }

// func insert(aNode *Node, x int) *Node {
// 	if aNode == nil {
// 		node := &Node{
// 			Val: x,
// 		}
// 		node.Next = node
// 		return node
// 	}

// 	cur := aNode
// 	next := aNode.Next
// 	for cur.Val <= next.Val {
// 		cur = cur.Next
// 		next = next.Next
// 		if next == aNode {
// 			break
// 		}
// 	}
// 	realNode := next
// 	for next.Val < x {
// 		cur = cur.Next
// 		next = next.Next
// 		if realNode == next {
// 			break
// 		}
// 	}
// 	node := &Node{
// 		Val: x,
// 	}
// 	cur.Next = node
// 	node.Next = next
// 	return cur
// }

// func insert(aNode *Node, x int) *Node {
//     if aNode == nil{
//         return &Node{Val:x}
//     }
//     for aNode.Val > x || aNode.Next.Val {

//     }
// }

// func sortList(head *ListNode) *ListNode {
//     if head == nil || head.Next == nil{
//         return head
//     }
//     slow,fast,pre := head,head,head
//     for fast != nil && fast.Next != nil{
//         pre = slow
//         slow = slow.Next
//         fast = fast.Next.Next
//     }
//     pre.Next = nil
//     left :=  sortList(head)
//     right := sortList(pre.Next)
//     return mergeList(left,right)
// }
// func mergeKLists(lists []*ListNode) *ListNode {
// 	if len(lists) == 0 {
// 		return nil
// 	} else if len(lists) == 1 {
// 		return lists[0]
// 	}

// 	for len(lists) != 1 {
// 		h := len(lists)
// 		for i := 0; i < h/2; i++ {
// 			lists[i] = mergeList(lists[i], lists[len(lists)-i-1])
// 		}
// 		if h%2 == 0 {
// 			lists = lists[:h/2]
// 		} else {
// 			lists = lists[:h/2+1]
// 		}
// 	}
// 	return lists[0]
// }
// func mergeList(left *ListNode, right *ListNode) *ListNode {
// 	dump := &ListNode{}
// 	temp := dump
// 	for left != nil && right != nil {
// 		if left.Val > right.Val {
// 			temp.Next = right
// 			right = right.Next
// 		} else {
// 			temp.Next = left
// 			left = left.Next
// 		}
// 		temp = temp.Next
// 	}
// 	if left != nil {
// 		temp.Next = left
// 	} else if right != nil {
// 		temp.Next = right
// 	}
// 	return dump.Next
// }

// func flatten(root *TreeNode)  {
//     if root == nil{
//         return
//     }
//     for root != nil{
//         next := root.Left
//         temp := next
//         for temp.Right != nil{
//             temp = temp.Right
//         }
//         temp.Right = root.Right
//         root.Left = nil
//         root.Right = next
//         root = next
//     }
// }
// func sortedListToBST(head *ListNode) *TreeNode {
// 	if head == nil {
// 		return nil
// 	}
// 	listnums := make([]int, 0)
// 	for head != nil {
// 		listnums = append(listnums, head.Val)
// 		head = head.Next
// 	}

// 	var reverseSorted func(nums []int) *TreeNode
// 	reverseSorted = func(nums []int) *TreeNode {
// 		if len(nums) == 0 {
// 			return nil
// 		}
// 		root := &TreeNode{
// 			Val: nums[len(nums)/2],
// 		}
// 		root.Left = reverseSorted(nums[:len(nums)/2])
// 		root.Right = reverseSorted(nums[len(nums)/2+1:])
// 		return root
// 	}
// 	return reverseSorted(listnums)
// }

// func deleteDuplicates(head *ListNode) *ListNode {
//     if head == nil{
//         return nil
//     }
//     mapv := make(map[int]bool)
//     dump := &ListNode{}
//     dump.Next = head
//     temp := dump
//     for head != nil{
//         if _,ok := mapv[head.Val];ok{
//             dump.Next = head.Next
//             head = head.Next
//         }else{
//             mapv[head.Val] = true
//             head = head.Next
//             temp = temp.Next
//         }
//     }
//     return dump.Next
// }

// func deleteNode(head *ListNode, val int) *ListNode {
//     if head == nil{
//         return nil
//     }

//     dump := &ListNode{}
//     dump.Next = head
//     temp := dump
//     for head != nil{
//         if head.Val == val{
//             temp.Next = temp.Next.Next
//             return dump.Next
//         }
//         head = head.Next
//         temp = temp.Next
//     }
//     return dump.Next
// }
// type Node struct {
// 	Val    int
// 	Next   *Node
// 	Random *Node
// }

// //判断链表是否有环
// func detectCycle(head *ListNode) *ListNode {
// 	if head == nil || head.Next == nil {
// 		return nil
// 	}
// 	slow := head
// 	fast := head.Next
// 	for fast != nil && fast.Next != nil {
// 		if slow == fast {
// 			slow = slow.Next
// 			fast = head
// 			for fast != slow {
// 				fast = fast.Next
// 				slow = slow.Next
// 			}
// 			return fast
// 		}
// 		slow = slow.Next
// 		fast = fast.Next.Next
// 	}
// 	return nil
// }

// func GetIntersectNode(list1 *ListNode, list2 *ListNode) *ListNode {
// 	if list1 == nil || list2 == nil {
// 		return nil
// 	}
// 	oraclel1 := detectCycle(list1)
// 	oraclel2 := detectCycle(list2)
// 	if oraclel1 == nil || oraclel2 == nil {
// 		return nil
// 	}
// 	if oraclel1 == oraclel2 {
// 		return GetOracleequal(oraclel1, list1, list2)
// 	}
// 	if oraclel1 != oraclel2 {
// 		return GetOraclenoequal(oraclel1, oraclel2)
// 	}
// 	return nil
// }

// func GetOraclenoequal(oracle1 *ListNode, oraclel2 *ListNode) *ListNode {
// 	temp := oracle1
// 	for temp.Next != oraclel2 {
// 		temp = temp.Next
// 		oraclel2 = oraclel2.Next
// 		if temp == oracle1 {
// 			return nil
// 		}
// 	}
// 	return oracle1
// }

// func GetOracleequal(oraclel *ListNode, list1 *ListNode, list2 *ListNode) *ListNode {
// 	cn1, cn2 := 0, 0
// 	temp := list1
// 	for list1 != oraclel {
// 		cn1++
// 		temp = temp.Next
// 	}
// 	temp = list2
// 	for temp != oraclel {
// 		cn2++
// 		temp = temp.Next
// 	}
// 	if cn1 > cn2 {
// 		n := cn1 - cn2
// 		for n != 0 {
// 			list1 = list1.Next
// 			n--
// 		}
// 	} else {
// 		n := cn2 - cn1
// 		for n != 0 {
// 			list2 = list2.Next
// 			n--
// 		}
// 	}
// 	for list1 != list2 {
// 		list1 = list1.Next
// 		list2 = list2.Next
// 	}
// 	return list1
// }

// func getIntersectionNode(headA, headB *ListNode) *ListNode {
//     if headA == nil || headB == nil{
//         return nil
//     }
//     temp := headA
//     lmp := make(map[*ListNode]bool)
//     for temp != nil{
//         if _,ok := lmp[temp];!ok{
//             lmp[temp]=true
//         }else{
//             break
//         }
//         temp = temp.Next
//     }
//     for headB != nil{
//         if _,ok := lmp[headB];ok{
//             return headB
//         }
//         headB = headB.Next
//     }
//     return nil
// }
// func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
// 	if l1 == nil {
// 		return l2
// 	} else if l2 == nil {
// 		return l1
// 	}
// 	rl1 := reverseList(l1)
// 	rl2 := reverseList(l2)

// 	dump := &ListNode{}
// 	count := 0
// 	temp := dump
// 	a, b, n := 0, 0, 0
// 	for rl1 != nil || rl2 != nil {
// 		if rl1 != nil {
// 			a = rl1.Val
// 			rl1 = rl1.Next
// 		} else {
// 			a = 0
// 		}
// 		if rl2 != nil {
// 			b = rl2.Val
// 			rl2 = rl2.Next
// 		} else {
// 			b = 0
// 		}
// 		n = a + b + count
// 		node := &ListNode{}
// 		if n >= 10 {
// 			node.Val = n % 10
// 			count = 1
// 		} else {
// 			node.Val = n
// 			count = 0
// 		}
// 		temp.Next = node
// 		temp = temp.Next
// 	}
// 	if count != 0 {
// 		node := &ListNode{
// 			Val: 1,
// 		}
// 		temp.Next = node
// 		temp = temp.Next
// 	}
// 	return reverseList(dump.Next)
// }
// func reverseList(l *ListNode) *ListNode {
// 	var pre *ListNode
// 	for l != nil {
// 		node := l.Next
// 		l.Next = pre
// 		pre = l
// 		l = node
// 	}
// 	return pre
// }

// func copyRandomList(head *Node) *Node {
//     if head == nil{
//         return nil
//     }
//     temp := head
//     for temp != nil{
//         node := &Node{
//             Val:temp.Val,
//             Random: temp.Random,
//         }
//         n := temp.Next
//         temp.Next = node
//         node.Next = n
//         temp = n
//     }
//     temp = head.Next
//     for temp != nil{
//         if temp.Random != nil{
//             temp.Random = temp.Random.Next
//         }
//         if temp.Next != nil{
//             temp = temp.Next.Next
//         }else{
//             break
//         }
//     }
//     l1 := head
//     l2 := head.Next
//     res := l2
//     for l2.Next != nil{
//         l1.Next = l2.Next
//         l2.Next = l1.Next
//         l1 = l1.Next
//         l2 = l2.Next
//     }
//     l1.Next = nil
//     return res
// }

// func isPalindrome(head *ListNode) bool {
//     if head != nil{
//         return false
//     }else if head.Next == nil{
//         return true
//     }
//     cut := head
//     next := head.Next
//     for next.Next != nil && next.Next != nil{
//         cut = cut.Next
//         next = next.Next.Next
//     }
//     pre := &ListNode{}
//     for cut != nil{
//         next = cut.Next
//         pre = cut.Next
//         pre = cut
//         cut = next
//     }
//     for pre != nil{
//         if pre.Val != head.Val{
//             return false
//         }
//         pre = pre.Next
//         head = head.Next
//     }
//     return true
// }
// func JosePushKill(head *ListNode, m int) {
// 	if head != nil || head.Next != nil || m < 1{
// 		return
// 	}
// 	k := m - 1
//     if k == 0{
//         temp := head
//         for head.Next != temp{
//             head = head.Next
//         }
//         head.Next = head
//         return
//     }
// 	for head.Next != head {
// 		if k == 1 {
// 			head.Next = head.Next.Next
// 			head = head.Next
// 			k = m - 1
// 		} else {
// 			head = head.Next
// 			k--
// 		}
// 	}
// 	return
// }

// func reverseList(head *ListNode) *ListNode {
// 	if head == nil {
// 		return nil
// 	}

// 	dump := &ListNode{}
// 	dump.Next = head
// 	pre := dump
// 	next := &ListNode{}
// 	for head != nil {
// 		next = head.Next
// 		head.Next = pre
// 		pre = head
// 		head = next
// 	}
// 	return pre
// }

// func removeNthFromEnd(head *ListNode, n int) *ListNode {
//     if head == nil{
//         return nil
//     }
//     dump := &ListNode{}
//     temp := dump
//     for temp!=nil && n != 0{
//         n--
//         temp = temp.Next
//     }
//     if n != 0{
//         return nil
//     }
//     dele := dump
//     for temp.Next != nil{
//         temp = temp.Next
//         dele = dele.Next
//     }
//     dele.Next = dele.Next.Next
//     return dump.Next
// }
// func getKthFromEnd(head *ListNode, k int) *ListNode {
//     if head == nil{
//         return nil
//     }
//     temp := head
//     for temp.Next != nil && k != 1{
//         temp = temp.Next
//     }
//     for temp.Next != nil{
//         head = head.Next
//         temp = temp.Next
//     }
//     return head
// }
// func GetNumber(nums []int, target int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	res := 0
// 	maxstack := make([]int, 0)
// 	minstack := make([]int, 0)
// 	i, j := 0, 0
// 	for i < len(nums) {
// 		for j < len(nums) {
// 			if len(minstack) == 0 || minstack[len(minstack)-1] != j {
// 				for len(maxstack) != 0 && nums[j] >= nums[maxstack[len(maxstack)-1]] {
// 					maxstack = maxstack[:len(maxstack)-1]
// 				}
// 				maxstack = append(maxstack, j)
// 				for len(minstack) != 0 && nums[j] <= nums[minstack[len(minstack)-1]] {
// 					minstack = minstack[:len(minstack)-1]
// 				}
// 				minstack = append(minstack, j)
// 			}

// 			if nums[maxstack[0]]-nums[minstack[0]] > target {
// 				break
// 			}
// 			j++
// 		}
// 		res += j - i
// 		if minstack[0] == i {
// 			minstack = minstack[1:]
// 		}
// 		if maxstack[0] == i {
// 			maxstack = maxstack[1:]
// 		}
// 		i++
// 	}
// 	return res
// }

// type NumMatrix struct {
// 	Matrix [][]int
// }

// func Constructor(matrix [][]int) NumMatrix {
// 	mat := NumMatrix{
// 		Matrix: matrix,
// 	}
// 	return mat
// }

// func (this *NumMatrix) SumRegion(row1 int, col1 int, row2 int, col2 int) int {
//     sum := 0
//     for i:=row1;i<row2;i++{
//         for j:=col1;j<col2;j++{
//             sum += this.Matrix[i][j]
//         }
//     }
//     return sum
// }

// func largestRectangleArea(heights []int) int {
// 	if len(heights) == 0 {
// 		return 0
// 	}
// 	help := []int{-1}
// 	res := math.MinInt32

// 	for i := 0; i < len(heights); i++ {
// 		for len(help) > 1 && heights[help[len(help)-1]] > heights[i] {
// 			w := i - help[len(help)-2] - 1
// 			res = max(res, w*heights[help[len(help)-1]])
// 			help = help[:len(help)-1]
// 		}
//         help = append(help,i)
// 	}
// 	for len(help)> 1 {
// 		w := len(heights) - help[len(help)-2] - 1
// 		res = max(res, w*heights[help[len(help)-1]])
// 		help = help[:len(help)-1]
// 	}
// 	return res
// }

// func getMaxMatrix(matrix [][]int) []int {
// 	if len(matrix) == 0 || len(matrix[0]) == 0 {
// 		return nil
// 	}
// 	m, n := len(matrix), len(matrix[0])
// 	result := []int{0, 0, len(matrix) - 1, len(matrix[0]) - 1}
// 	res := math.MinInt32
// 	for i := 0; i < m; i++ {
// 		help := make([]int, n)
// 		sum := 0
// 		t := 0
// 		for j := i; j < m; j++ {
// 			for k := 0; k < n; k++ {
// 				help[k] += matrix[j][k]
// 				if sum < 0 {
// 					sum = 0
// 					t = k
// 				}
// 				sum += help[k]
// 				if sum > res {
// 					res = sum
// 					result = []int{i, t, j, k}
// 				}
// 			}
// 		}
// 	}
// 	return result
// }

// func maxSubArray(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	f := make([]int, len(nums))
// 	f[0] = nums[0]
// 	for i := 1; i < len(nums); i++ {
// 		if f[i-1] < 0 {
// 			f[i] = nums[i]
// 		} else {
// 			f[i] = f[i-1] + nums[i]
// 		}
// 	}
// 	res := math.MinInt32
// 	for i := 0; i < len(f); i++ {
// 		if res > f[i] {
// 			res = f[i]
// 		}
// 	}
// 	return f[len(nums)-1]
// }

// func getMaxMatrix(matrix [][]int) []int {
//     if len(matrix) == 0 || len(matrix[0]) == 0 {
// 		return nil
// 	}
// 	ml := make([]int, len(matrix[0]))
//     result := make([]int,0)
//     r1,c1,r2,c2 := 0,0,0,0
//     sum := 0

// 	for i := 0; i < len(matrix); i++ {
// 		for j := 0; j < len(matrix[0]); j++ {
// 			if matrix[i][j] == '0' {
// 				ml[j] = 0
// 			} else {
// 				ml[j] += 1
// 			}
// 		}
// 		stack := []int{-1}
// 		for k, l := range ml {
// 			for len(stack) > 1 && l < ml[stack[len(stack)-1]] {
// 				w := k - stack[len(stack)-2] - 1
//                 if sum < xxx{
//                     sum =
//                     r1,c1 = i-l+1,stack[len(stack)-2]
//                 }
// 				sum = max(sum, w*ml[stack[len(stack)-1]])
// 				stack = stack[:len(stack)-1]
// 			}
// 			for len(stack) > 1 {
// 				w := k - stack[len(stack)-2] - 1
// 				sum = max(sum, w*ml[stack[len(stack)-1]])
// 				stack = stack[:len(stack)-1]
// 			}
// 		}
// 	}
//     result = append(result,[]int{r1,c1,r2,c2}...)
// 	return result
// }

// func maximalRectangle(matrix []string) int {
// 	if len(matrix) == 0 || len(matrix[0]) == 0 {
// 		return 0
// 	}
// 	ml := make([]int, len(matrix[0]))
// 	// for i := 0; i < len(matrix[0]); i++ {
// 	// 	if matrix[0][i] == '1' {
// 	// 		ml[i] = 1
// 	// 	}
// 	// }
// 	result := 0

// 	for i := 0; i < len(matrix); i++ {
// 		for j := 0; j < len(matrix[0]); j++ {
// 			if matrix[i][j] == '0' {
// 				ml[j] = 0
// 			} else {
// 				ml[j] += 1
// 			}
// 		}
// 		stack := []int{-1}
// 		for k, l := range ml {
// 			for len(stack) > 1 && l < ml[stack[len(stack)-1]] {
// 				w := k - stack[len(stack)-2] - 1
// 				result = max(result, w*ml[stack[len(stack)-1]])
// 				stack = stack[:len(stack)-1]
// 			}
// 			for len(stack) > 1 {
// 				w := k - stack[len(stack)-2] - 1
// 				result = max(result, w*ml[stack[len(stack)-1]])
// 				stack = stack[:len(stack)-1]
// 			}
// 		}
// 	}
// 	return result
// }
// func rightWaystack(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	res := make([][]int, len(nums))
// 	for i := 0; i < len(nums); i++ {
// 		res[i] = make([]int, 2)
// 	}
// 	help := make([]int, 0)

// 	for i := 0; i < len(nums); i++ {
// 		for len(help) != 0 && nums[help[len(help)-1]] > nums[i] {
// 			res[help[len(help)-1]][1] = i
// 			help = help[:len(help)-1]
// 		}
// 		k := len(help)
// 		for k != 0 && nums[i] == nums[help[k-1]] {
// 			k -= 1
// 		}
// 		if k != 0 {
// 			res[i][0] = help[k-1]
// 		} else {
// 			res[i][0] = -1
// 		}
// 		help = append(help, i)
// 	}
// 	for _, v := range help {
// 		res[v][1] = len(nums)
// 	}
// 	result := 0
// 	for i := 0; i < len(res); i++ {
// 		if nums[i]*(res[i][1]-res[i][0]-1) > result {
// 			result = nums[i] * (res[i][1] - res[i][0] - 1)
// 		}
// 	}
// 	return result
// }

// func rightWaystack(nums []int) [][]int {
// 	if len(nums) == 0 {
// 		return nil
// 	}
// 	res := make([][]int, len(nums))
// 	for i := 0; i < len(nums); i++ {
// 		res[i] = make([]int, 2)
// 	}
// 	help := make([]int, 0)

// 	for i := 0; i < len(nums); i++ {
// 		for len(help) != 0 && nums[help[len(help)-1]] > nums[i] {
// 			res[help[len(help)-1]][1] = i
// 			help = help[:len(help)-1]
// 		}
// 		k := len(help)
// 		for k != 0 && nums[i] == nums[help[k-1]] {
// 			k -= 1
// 		}
// 		if k != 0 {
// 			res[i][0] = help[k-1]
// 		} else {
// 			res[i][0] = -1
// 		}
// 		help = append(help, i)
// 	}
// 	for _, v := range help {
// 		res[v][1] = -1
// 	}
// 	return res
// }

// func getMaxWindow(nums []int, w int) []int {
// 	if len(nums) == 0 || w > len(nums) || w < 1 {
// 		return nil
// 	}
// 	res := make([]int, len(nums))
// 	help := make([]int, 0)
// 	for i := 0; i < len(nums); i++ {
// 		for len(help) != 0 && nums[i] >= nums[help[len(help)-1]] {
// 			help = help[:len(help)-1]
// 		}
// 		help = append(help, i)
// 		if help[0] <= i-w {
// 			help = help[1:]
// 		}
// 		res[i] = nums[help[0]]
// 	}
// 	return res[w-1:]
// }

// func hanota(A []int, B []int, C []int) []int {
// 	fmt.Println(A, B, C)
// 	if len(A) == 0 {
// 		return nil
// 	}
// 	var move func(int, *[]int, *[]int, *[]int)
// 	move = func(num int, a *[]int, b *[]int, c *[]int) {

// 		if num < 0 {
// 			return
// 		}
// 		if num == 1 {
// 			*c = append(*c, (*a)[len(*a)-1])
// 			// fmt.Println("B", B, "C", C, c)
// 			*a = (*a)[:len(*a)-1]
// 			return
// 		}
// 		move(num-1, a, b, c)
// 		move(1, a, c, b)
// 		move(num-1, c, b, a)
// 		move(1, b, a, c)
// 		move(num-1, a, b, c)
// 	}
// 	move(len(A), &A, &B, &C)
// 	fmt.Println(A, B, C)
// 	return C
// }

// func main() {
// 	Stack := &SortStack{
// 		stack: make([]int, 0),
// 		help:  make([]int, 0),
// 	}
// 	N := 0
// 	a := 0
// 	fmt.Scan(&N)

// 	for i := 0; i < N; i++ {
// 		fmt.Scan(&a)
// 		Stack.Sort(a)
// 	}

// 	for _, k := range Stack.stack {
// 		fmt.Printf("%v ", k)
// 	}
// }

// func (this *SortStack) Sort(val int) {
// 	if len(this.help) == 0 {
// 		this.help = append(this.help, val)
// 		this.stack = append(this.stack, val)
// 		return
// 	}
// 	for i := len(this.help) - 1; i >= 0; i-- {
// 		if val <= this.help[i] {
// 			this.help = append(this.help[:i+1], append([]int{val}, this.help[i+1:]...)...)
// 			break
// 		} else if val > this.help[i] && i == 0 {
// 			this.help = append([]int{val}, this.help...)
// 		}
// 	}
// 	this.stack = this.stack[:0]
// 	for i := 0; i < len(this.help); i++ {
// 		this.stack = append(this.stack, this.help[len(this.help)-1-i])
// 	}
// 	fmt.Println(this.stack, this.help)

// }

// func (this *SortStack) Sort(val int) {
// 	if len(this.stack) == 0 {
// 		this.stack = append(this.stack, val)
// 		return
// 	}
// 	left := 0
// 	right := len(this.stack) - 1
// 	for left+1 < right {
// 		mid := (left + right) / 2
// 		if val == this.stack[mid] {
// 			this.stack = append(this.stack[:mid+1], append([]int{val}, this.stack[mid+1:]...)...)
// 			return
// 		} else if val > this.stack[mid] {
// 			left = mid
// 		} else {
// 			right = mid
// 		}
// 	}
// 	if val <= this.stack[left] {
// 		this.stack = append(this.stack[:left], append([]int{val}, this.stack[left:]...)...)
// 	} else if val >= this.stack[right] {
// 		this.stack = append(this.stack[:right+1], append([]int{val}, this.stack[right+1:]...)...)
// 	} else if val > this.stack[left] && val < this.stack[right] {
// 		this.stack = append(this.stack[:left+1], append([]int{val}, this.stack[left+1:]...)...)
// 	}
// }

// func Constructor() SortedStack {
// 	return SortedStack{
// 		stack: make([]int, 0),
// 	}
// }
// func test22(stack *[]int, val int) {
// 	*stack = append(*stack, val)
// 	// fmt.Println("stack3", stack)
// }

// func (this *SortedStack) Pop() {
// 	this.stack = this.stack[:len(this.stack)-1]
// }

// func (this *SortedStack) Peek() int {
// 	return this.stack[len(this.stack)-1]
// }

// func (this *SortedStack) IsEmpty() bool {
// 	return len(this.stack) == 0
// }

// func (t *Twolist) Add(value int) {
// 	t.stackdata = append(t.stackdata, value)
// }
// func (t *Twolist) Poll() {
// 	t.stackdata = t.stackdata[1:]
// }
// func (t *Twolist) Peek() int {
// 	return t.stackdata[0]
// }

// type MinStack struct {
// 	numstack []int
// 	minstack []int
// }

// /** initialize your data structure here. */
// func Constructor() MinStack {
// 	stack := MinStack{
// 		numstack: make([]int, 0),
// 		minstack: make([]int, 0),
// 	}
// 	return stack
// }

// func (this *MinStack) Push(x int) {
//     this.numstack = append(this.numstack,x)
//     if x < this.minstack[len(this.minstack)-1]{
//         this.minstack = append(this.minstack, x)
//     }else{
//         this.minstack = append(this.minstack,this.minstack[len(this.minstack)-1])
//     }
// }

// func (this *MinStack) Pop() {
//     this.minstack = this.minstack[:len(this.minstack)-1]
//     this.numstack = this.numstack[:len(this.numstack)-1]
// }

// func (this *MinStack) Top() int {
//     return this.numstack[len(this.numstack)-1]
// }

// func (this *MinStack) Min() int {
//     return this.minstack[len(this.minstack)-1]
// }

// func findMaxForm(strs []string, m int, n int) int {
// 	if len(strs) == 0 || m < 0 || n < 0 {
// 		return 0
// 	}

// 	dp := make([][]int, m+1)
// 	for i := 0; i < len(dp); i++ {
// 		dp[i] = make([]int, n+1)
// 	}

// 	for i := 0; i < len(strs); i++ {
// 		mm := strings.Count(strs[i], "0")
// 		nn := len(strs[i]) - mm
// 		for j := m; j >= mm; j-- {
// 			for z := n; z >= nn; z-- {
// 				dp[j][z] = max(dp[j][z], dp[j-mm][z-nn]+1)
// 			}
// 		}
// 	}
// 	return dp[m][n]
// }

// func main() {
// 	go haha()
// }
// func main() {
// 	ctx := context.Background()
// 	ctx, cancel := context.WithCancel(ctx)
// 	go func() {
// 		operation2(ctx)
// 	}()
// 	err := operation1(ctx)
// 	if err != nil {
// 		cancel()
// 	}
// }

// func operation1(ctx context.Context) error {
// 	time.Sleep(100 * time.Millisecond)
// 	return errors.New("failed")
// }

// func operation2(ctx context.Context) error {
// 	select {
// 	case <-time.After(500 * time.Millisecond):
// 		fmt.Println("500")
// 	case <-ctx.Done():
// 		fmt.Println("halted operation2")
// 		return ctx.Err()
// 	}
// 	return nil
// }

// func findMaxForm(strs []string, m int, n int) int {
// 	if len(strs) == 0 || m < 0 || n < 0 {
// 		return 0
// 	}

// 	mp := make([][]int, len(strs))

// 	for i := 0; i < len(strs); i++ {
// 		mm, nn := SeekStrs(strs[i])
// 		mp[i] = make([]int, 2)
// 		mp[i][0] = mm
// 		mp[i][1] = nn
// 	}

// 	res := 0
// 	var reveseFindStr func(index int, mm int, nn int, cnt int)
// 	reveseFindStr = func(index int, mm int, nn int, cnt int) {
// 		if mm+mp[index][0] > m || nn+mp[index][1] > n {
// 			return
// 		} else {
// 			if cnt+1 > res {
// 				res = cnt + 1
// 			}
// 		}

// 		for i := index + 1; i < len(mp); i++ {
// 			reveseFindStr(i, mm+mp[index][0], nn+mp[index][1], cnt+1)
// 		}
// 	}
// 	for i := 0; i < len(mp); i++ {
// 		reveseFindStr(i, 0, 0, 0)
// 	}

// 	fmt.Println(mp)
// 	return res
// }

func SeekStrs(strs string) (int, int) {
	m := 0
	n := 0
	for i := 0; i < len(strs); i++ {
		if strs[i] == '0' {
			m++
		} else {
			n++
		}
	}
	return m, n
}

// func makesquare(matchsticks []int) bool {
//     if len(matchsticks) == 0{
//         return false
//     }
//     sum := 0
//     mp := make(map[int]int)
//     for _,v := range matchsticks{
//         sum += v
//         mp[v]++
//     }
//     if sum % 4 != 0{
//         return false
//     }
//     k := sum / 4
//     cnt := 4
//     for _,v := range matchsticks{
//         if i := mp[k-v];i>0{
//             cnt--
//             mp[k-v]--
//             mp[v]--
//         }
//         if cnt == 0{
//             return true
//         }
//     }
//     return false
// }
// func corpFlightBookings(bookings [][]int, n int) []int {
// 	if len(bookings) == 0 {
// 		return nil
// 	}
// 	sort.Slice(bookings, func(i, j int) bool {
// 		return bookings[i][0] < bookings[j][0]
// 	})

// 	dp := make([]int, n+1)
// 	for i := 1; i < len(dp); i++ {
// 		for j := 0; j < len(bookings); j++ {
// 			if bookings[j][0] <= i {
// 				dp[i] += bookings[j][2]
// 			} else {
// 				break
// 			}
// 		}
// 	}
// 	return dp[1:]
// }

// func corpFlightBookings(bookings [][]int, n int) []int {
//     if len(bookings) == 0{
//         return nil
//     }
//     res := make([]int,n)

//     for i:=0;i<len(bookings);i++{
//         for j:=bookings[i][0];j<=bookings[i][1];j++{
//             res[j-1]+=bookings[i][2]
//         }
//     }
//     return res
// }
// func totalFruit(fruits []int) int {
//     if len(fruits) <=2 {
//         return len(fruits)
//     }

//     dp := make([]int,len(fruits))
//     dp[0] = 1
//     res := 0
//     for i:=1;i<len(fruits);i++{
//         dp[i] = 1
//         if fruits[i] == fruits[i-1]{
//             dp[i] += dp[i-1]
//         }else if fruits[i] != fruits[i-1]{
//             temp := fruits[i-1]
//             k := i-1
//             cnt := 0
//             for k >=0 {
//                 if fruits[k] == temp{
//                     k--
//                     cnt++
//                 }else if fruits[k] != temp{
//                     if fruits[k] != fruits[i]{
//                         dp[i]+=cnt
//                     }else{
//                         dp[i]+=dp[i-1]
//                     }
//                     break
//                 }
//             }
//         }
//         if res < dp[i]{
//             res = dp[i]
//         }
//     }
//     return res
// }

// func numSubarrayBoundedMax(nums []int, left int, right int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	dp := make([]int, len(nums))
// 	if nums[0] <= right && nums[0] >= left {
// 		dp[0] = 1
// 	}
// 	for i := 1; i < len(nums); i++ {
// 		if nums[i] <= right && nums[i] >= left {
//             k := i-1
// 			for nums[k] < left {
// 				dp[i] += 1
//                 k--
// 			}
// 			dp[i] += 1
// 			dp[i] += dp[k]
// 		} else if nums[i] > right {
// 			dp[i] = 0
// 		} else if nums[i] < left {
// 			dp[i] += dp[i-1]
// 		}
// 	}
// 	sum := 0
// 	for _, v := range dp {
// 		sum += v
// 	}
// 	return sum
// }

// func findSubstringInWraproundString(p string) int {
// 	if len(p) < 2 {
// 		return len(p)
// 	}
// 	mp := make([]int, 123)
// 	dp := make([]int, len(p))
// 	dp[0] = 1
// 	mp[p[0]] = 1
// 	for i := 1; i < len(p); i++ {
// 		dp[i] = 1
// 		if p[i]-p[i-1] == 1 || int(p[i])-int(p[i-1]) == -25 {
// 			dp[i] += dp[i-1]
// 		}
// 		mp[p[i]] = max(mp[p[i]], dp[i])
// 	}
// 	sum := 0
// 	for _, v := range mp {
// 		sum += v
// 	}
// 	return sum
// }

// func canIWin(maxChoosableInteger int, desiredTotal int) bool {
// 	if maxChoosableInteger >= desiredTotal {
// 		return true
// 	}
// 	if (maxChoosableInteger+1)*maxChoosableInteger/2 < desiredTotal {
// 		return false
// 	}
// 	dp := make([]bool, 1<<maxChoosableInteger)
// 	return reverseCanIwin(maxChoosableInteger, desiredTotal, dp, 0)
// }

// func reverseCanIwin(maxChoosableInteger int, desiredTotal int, dp []bool, state int) bool {
// 	if dp[state] {
// 		return dp[state]
// 	}
// 	for i := 1; i <= maxChoosableInteger; i++ {
// 		cur := 1 << (i - 1)
// 		if cur&state != 0 {
// 			continue
// 		}

// 		if desiredTotal-i <= 0 || !reverseCanIwin(maxChoosableInteger, desiredTotal-i, dp, state|cur) {
// 			dp[state] = true
// 			return true
// 		}
// 	}
// 	return false
// }

// func eraseOverlapIntervals(intervals [][]int) int {
// 	if len(intervals) == 0 || len(intervals[0]) == 0 {
// 		return 0
// 	}
// 	sort.Slice(intervals, func(i, j int) bool {
// 		return intervals[i][1] < intervals[j][1]
// 	})
// 	index := intervals[0][1]
// 	num := 0
// 	ans := 1
// 	for i := 1; i < len(intervals); i++ {
// 		if intervals[i][1] == index {
// 			num++
// 		} else {
// 			break
// 		}
// 	}
// 	for i := num; i < len(intervals); i++ {
// 		if intervals[i][0] < index {
// 			continue
// 		} else {
// 			ans++
// 			index = intervals[i][1]
// 		}
// 	}
// 	return len(intervals) - ans
// }

// func numberOfArithmeticSlices(nums []int) int {
//     if len(nums) == 1{
//         return 0
//     }
//     d,t := nums[0]-nums[1],0
//     ans := 0
//     for i:=2;i<n;i++{
//         if nums[i-1]-nums[i] == d{
//             t++
//         }else{
//             d=nums[i-1]-nums[i]
//             t=0
//         }
//         ans += t
//     }
//     return ans
// }
// func integerReplacement(n int) int {
// 	f := make([]int, n+1)
// 	tmp := make([]int, 0)

// 	for i := 2; i <= n; i++ {
// 		f[i] = f[i/2] + 1
// 	}

// 	if n < 3 {
// 		return f[n]
// 	}

// 	tmp = append(tmp, 3)
// 	for len(tmp) != 0 {
// 		k := tmp[0]
// 		if k == n {
// 			break
// 		}
// 		tmp = tmp[1:]
// 		f[k] = min(f[k-1]+1, f[k+1]+1)
// 		x := k * 2
// 		for k = k * 2; k <= n; k *= 2 {
// 			f[k] = f[k/2] + 1
// 		}
// 		if x > n {
// 			continue
// 		}
// 		f[x-1] = min(f[x]+1, f[x-2]+1)
// 		tmp = append(tmp, x-1)
// 		if x+1 <= n {
// 			tmp = append(tmp, x+1)
// 			f[x+1] = f[x] + 1
// 			if x+2 <= n {
// 				f[x+1] = min(f[x+1], f[x+2]+1)
// 			}
// 		}
// 	}
// 	if n%2 != 0 {
// 		f[n] = f[n-1] + 1
// 		f[n] = min(f[n], 2+f[(n+1)/2])
// 	}
// 	fmt.Println(f)
// 	return f[n]
// }

// func maxRotateFunction(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	sum := 0
// 	res := 0
// 	n := len(nums) - 1
// 	f := make([]int, len(nums))

// 	for i := 0; i < len(nums); i++ {
// 		sum += nums[i]
// 	}
// 	for i := 0; i < len(nums); i++ {
// 		f[0] += i * nums[i]
// 	}

// 	for i := n; i >= 1; i-- {
// 		f[n-i+1] = f[n-i] + sum - nums[i] - nums[i]*n

// 	}
// 	fmt.Println(f)
// 	for _, v := range f {
// 		if res < v {
// 			res = v
// 		}
// 	}
// 	return res
// }

// func combinationSum4(nums []int, target int) int {
//     if len(nums) == 0{
//         return 0
//     }
//     mf := make(map[int]bool)
//     for i:=0;i<len(nums);i++{
//         mf[nums[i]]=true
//     }
//     f := make([]int,target+1)
//     for i:=1;i<=target;i++{
//         if ok,_ := mf[target];ok{
//             f[i] = 1
//         }else{
//             f[i] = 0
//         }
//         for j:=0;i - nums[j] > 0;j++{
//             f[i] += f[i-nums[j]]
//         }
//     }
//     return f[target]
// }

// func combinationSum4(nums []int, target int) int {
// 	result := 0
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	sort.Ints(nums)
// 	var reverseCombination func(nums []int, res int)
// 	reverseCombination = func(nums []int, res int) {
// 		if res == target {
// 			result++
// 			return
// 		}
// 		for i := 0; i < len(nums); i++ {
// 			if res+nums[i] > target {
// 				return
// 			}
//             if
// 			reverseCombination(nums, res+nums[i])
// 		}
// 	}
// 	reverseCombination(nums, 0)
// 	return result
// }

// func wiggleMaxLength(nums []int) int {
// 	if len(nums) < 1 {
// 		return len(nums)
// 	}

// 	f := make([]int, len(nums))
// 	f[0] = 1
// 	for i := 1; i < len(nums); i++ {
// 		f[i] = 1
// 		for j := 0; j < i; j++ {
// 			if j-1 >= 0 && nums[j]-nums[j-1] > 0 && nums[j]-nums[i] > 0 || nums[j]-nums[j-1] < 0 && nums[j]-nums[i] < 0 {
// 				f[i] = max(f[i], f[j]+1)
// 			} else if j-1 < 0 && nums[j] != nums[i] {
// 				f[i] = max(f[i], f[j]+1)
// 			}
// 		}
// 	}
// 	return f[len(nums)-1]
// }

// func getMoneyAmount(n int) int {
//     if n == 1{
//         return 0
//     }
//     f := make([][]int,n+1)
//     for i:=0;i<len(f);i++{
//         f[i] := make([]int,n+1)
//     }
//     for i:=0;i<len(f);i++{
//         for j:=0;j<len(f);j++{
//             f[i][j] = 1<<31
//         }
//     }
//     for i:=0;i<len(f);i++{
//         f[i][i] = 0
//     }
//     for j:=2;j<=n;j++{
//         for i:=j-1;i>=1;i--{
//             for k:=i+1;k<=j-1;k++{
//                 f[i][j]  = min(f[i][j],k+max(f[i][k-1],f[k+1][j]))
//             }
//             f[i][j] = min(i+f[i+1][j],f[i][j])
//             f[i][j] = min(f[i][j],j+f[i][j-1])
//         }
//     }
//     return f[1][n]
// }
// func getMoneyAmount(n int) int {
//     if n == 1{
//         return 0
//     }
//     f := make([]int,n+1)
//     f[0] = 0
//     f[1] = 0
//     for i:=2;i<=n;i++{
//         f[n] = f[n-1] + i
//     }
//     return f[n]
// }
// func largestDivisibleSubset(nums []int) []int {
// 	sort.Ints(nums)
// 	f := make([]int, len(nums))
//     g := make([]int,len(nums))
// 	f[0] = 1
//     for i:=1;i<len(nums);i++{
//         f[i] = 1
//         pre := i
//         for j:=0;j<i;j++{
//             if nums[i] % nums[j] == 0{
//                 if f[j]+1 > f[i]{
//                     f[i] = f[j] + 1
//                     pre = j
//                 }
//             }
//         }
//         g[i] = pre
//     }
//     maxlen := -1
//     maxindex:= -1
//     for i,v := range f{
//         if v > maxlen{
//             maxlen = v
//             maxindex = i
//         }
//     }
//     res := make([]int,0)
//     for len(res) != maxlen{
//         res = append(res,nums[maxindex])
//         maxindex = g[maxindex]
//     }
//     return res
// }

// func countNumbersWithUniqueDigits(n int) int {
//     if n == 0{
//         return 2
//     }

//     f := make([]int,n+1)
//     f[0] = 2
//     f[1] = 10
//     for i:=2;i<=n;i++{
//         j := 0
//         sum :=1
//         for j < i{
//             sum = sum * (9 - j)
//             j++
//         }
//         f[i] = f[i-1] + sum
//     }
//     return f[n]
// }

// func integerBreak(n int) int {
//     if n == 0{
//         return 0
//     }
//     f := make([]int,n+1)
//     f[0] = 1
//     f[1] = 1
//     for i:=2;i<=n;i++{
//         f[i]=f[i-1] * 1
//         for j:=1;j<i;j++{
//             f[i] = max(f[i],j * max(f[i-j],i-j))
//         }
//     }
//     return f[n]
// }

// func increasingBST(root *TreeNode) *TreeNode {
//     if root == nil{
//         return nil
//     }
//     dump := &TreeNode{}
//     temp := dump
//     var reverseIncrea func(root *TreeNode)
//     reverseIncrea = func(root *TreeNode){
//         if root == nil{
//             return
//         }
//         reverseIncrea(root.Left)
//         temp.Right = root
//         root.Left = nil
//         temp = root
//         reverseIncrea(root.Right)
//     }
//     reverseIncrea(root)
//     return dump
// }

// func allPossibleFBT(n int) []*TreeNode {
//     if n % 2 == 0 {
//         return nil
//     }
//     result := make([]*TreeNode,0)

//     var reverseAll func(root *TreeNode,fx string,n int)
//     reverseAll = func(root *TreeNode,fx string,n int){
//         node := &TreeNode{
//             Val:0,
//         }
//         if fx == "left"{
//             root.Left = node
//         }else{
//             root.Right = node
//         }
//         if n-1 == 0{
//             return
//         }
//         for i:=1;i<=n-1;i+=2{
//             reverseAll(root,"left",i)
//             reverseAll(root,"right",n-1-i)
//         }
//     }
// }

// func constructFromPrePost(preorder []int, postorder []int) *TreeNode {
//     if len(preorder) == 0{
//         return nil
//     }
//     root := &TreeNode{
//         Val:preorder[0],
//     }
//     preorder = preorder[1:]
//     postorder = postorder[:len(postorder)-1]
//     indexpre := FindIndex(preorder,postorder[len(postorder)-1])
//     indexpro := FindIndex(postorder,preorder[0])
//     root.Left = constructFromPrePost(preorder[:indexpre],postorder[:indexpro+1])
//     root.Right = constructFromPrePost(preorder[indexpre:],postorder[indexpro+1:])
//     return root
// }

func FindIndex(order []int, val int) int {
	for i := 0; i < len(order); i++ {
		if order[i] == val {
			return i
		}
	}
	return 0
}

// func distanceK(root, target *TreeNode, k int) (ans []int) {
//     // 从 root 出发 DFS，记录每个结点的父结点
//     parents := map[int]*TreeNode{}
//     var findParents func(*TreeNode)
//     findParents = func(node *TreeNode) {
//         if node.Left != nil {
//             parents[node.Left.Val] = node
//             findParents(node.Left)
//         }
//         if node.Right != nil {
//             parents[node.Right.Val] = node
//             findParents(node.Right)
//         }
//     }
//     findParents(root)

//     // 从 target 出发 DFS，寻找所有深度为 k 的结点
//     var findAns func(*TreeNode, *TreeNode, int)
//     findAns = func(node, from *TreeNode, depth int) {
//         if node == nil {
//             return
//         }
//         if depth == k { // 将所有深度为 k 的结点的值计入结果
//             ans = append(ans, node.Val)
//             return
//         }
//         if node.Left != from {
//             findAns(node.Left, node, depth+1)
//         }
//         if node.Right != from {
//             findAns(node.Right, node, depth+1)
//         }
//         if parents[node.Val] != from {
//             findAns(parents[node.Val], node, depth+1)
//         }
//     }
//     findAns(target, nil, 0)
//     return
// }

// type nodeDeep struct{
// 	node *TreeNode
// 	maxdeep int
// }
// func subtreeWithAllDeepest(root *TreeNode) *TreeNode {
// 	if root == nil{
// 		return nil
// 	}
// 	var reverseSubtree func(*TreeNode,int) *nodeDeep
// 	reverseSubtree = func(root *TreeNode,deep int) *nodeDeep{
// 		if root == nil{
// 			nd := &nodeDeep{
// 				maxdeep: deep,
// 			}
// 			return nd
// 		}
// 		left := reverseSubtree(root.Left,deep+1)
// 		right := reverseSubtree(root.Right,deep+1)
// 		if left.maxdeep == right.maxdeep{
// 			left.node = root
// 			return left
// 		}
// 		if left.maxdeep > right.maxdeep{
// 			return left
// 		}
// 		return right
// 	}
// 	nd := reverseSubtree(root,0)
// 	return nd.node
// }
// func pruneTree(root *TreeNode) *TreeNode {
// 	var reversePrune func(*TreeNode) int
// 	reversePrune = func(root *TreeNode) int{
// 		if root == nil{
// 			return 0
// 		}
// 		left := reversePrune(root.Left)
// 		right := reversePrune(root.Right)
// 		if left == 0{
// 			root.Left = nil
// 		}
// 		if right == 0{
// 			root.Right = nil
// 		}
// 		if root.Val == 1 || left == 1 || right == 1{
// 			return 1
// 		}
// 		return 0
// 	}
// 	reversePrune(root)
// 	return root
// }

// type Node struct {
// 	Val int
// 	Children []*Node
// }

// func levelOrder(root *Node) [][]int {
// 	result := make([][]int,0)
// 	nodes := make([]*Node,0)
// 	nodes = append(nodes,root)

// 	for len(nodes) > 0{
// 		n := len(nodes)
// 		res := make([]int,0)
// 		for i:=0;i<n;i++{
// 			node := nodes[0]
// 			nodes = nodes[1:]
// 			for _,v := range node.Children{
// 				if v != nil{
// 					nodes = append(nodes,v)
// 				}
// 			}
// 			res = append(res,node.Val)
// 		}
// 		result = append(result,res)
// 	}
// 	return result
// }

// func longestUnivaluePath(root *TreeNode) int {
// 	max := -1
// 	var revesUnival func(*TreeNode) int
// 	revesUnival = func(root *TreeNode)int{
// 		if root == nil{
// 			return -1
// 		}
// 		num := 0
// 		ln := 0
// 		rn := 0
// 		left := revesUnival(root.Left)
// 		right := revesUnival(root.Right)
// 		if left != -1 && root.Val == root.Left.Val{
// 			ln = left+1
// 		}
// 		if right != -1 && root.Val == root.Right.Val{
// 			rn =  right + 1
// 		}
// 		// if left == -1 && right == -1{
// 		// 	num = 0
// 		// }
// 		num = ln + rn
// 		if num > max{
// 			max = num
// 		}
// 		if ln > rn{
// 			return ln
// 		}

// 		return rn

// 	}
// 	revesUnival(root)
// 	return max
// }

// func trimBST(root *TreeNode, low int, high int) *TreeNode {
//     if root == nil{
//         return nil
//     }
// 	if root.Val < low || root.Val > high{
// 		left := trimBST(root.Left,low,high)
// 		right := trimBST(root.Right,low,high)
// 		if left != nil{
// 			return left
// 		}
// 		if right != nil{
// 			return right
// 		}
// 		return nil
// 	}
// 	left := trimBST(root.Left,low,high)
// 	right := trimBST(root.Right,low,high)
// 	root.Left = left
// 	root.Right = right
// 	return root
// }

// type item struct{
// 	position int
// 	node *TreeNode
// }
// func widthOfBinaryTree(root *TreeNode) int {
// 	if root == nil{
// 		return 0
// 	}
// 	res := 1
// 	items:=[]item{{0,root}}
// 	for len(items) != 0{
// 		if items[len(items)-1].position - items[0].position + 1 > res{
// 			res = items[len(items)-1].position - items[0].position + 1
// 		}
// 		tmp := []item{}
// 		for _,v := range items{
// 			if v.node.Left != nil{
// 				k := item{
// 					position:v.position*2,
// 					node : v.node.Left,
// 				}
// 				tmp = append(tmp,k)
// 			}
// 			if v.node.Right != nil{
// 				k := item{
// 					position:v.position*2 + 1,
// 					node : v.node.Right,
// 				}
// 				tmp = append(tmp,k)
// 			}
// 		}
// 		items = tmp
// 	}
// 	return res
// }
// func widthOfBinaryTree(root *TreeNode) int {
// 	if root == nil{
// 		return 0
// 	}
// 	res := 1

// 	nodes := make([]*TreeNode,0)
// 	nodes = append(nodes,root)

// 	for len(nodes) != 0{
// 		n := len(nodes)
// 		for i:=0;i<n;i++{
// 			node := nodes[0]
// 			nodes = nodes[1:]
// 			if node == nil{
// 				nodes = append(nodes,nil)
// 				nodes = append(nodes,nil)
// 				continue
// 			}

// 			if node.Left != nil{
// 				nodes = append(nodes,node.Left)
// 			}else{
// 				nodes = append(nodes,nil)
// 			}
// 			if node.Right != nil{
// 				nodes = append(nodes,node.Right)

// 			}else{
// 				nodes = append(nodes,nil)
// 			}
// 		}
// 		for len(nodes) > 0 && nodes[0] == nil{
// 			nodes = nodes[1:]

// 		}
// 		for len(nodes)>0 && nodes[len(nodes)-1] == nil{
// 			nodes = nodes[:len(nodes)-1]
// 		}
// 		if res > len(nodes){
// 			res = len(nodes)
// 		}

// 	}
// 	return res
// }

// func printTree(root *TreeNode) [][]string {
// 	res := make([][]string,0)
// 	nodes := make([]*TreeNode,0)
// 	nodes = append(nodes,root)

// 	for len(nodes) != 0{
// 		n := len(nodes)
// 		str := make([]string,0)
// 		for i:=0;i<n;i++{
// 			node := nodes[0]
// 			nodes = nodes[1:]
// 			if node == nil{
// 				str = append(str,"#","#")
// 				continue
// 			}
// 			str = append(str,string(node.Val))
// 			if node.Left != nil{
// 				nodes = append(nodes,node.Left)
// 			}else{
// 				nodes = append(nodes,nil)
// 			}
// 			if node.Right != nil{
// 				nodes = append(nodes,node.Right)
// 			}else{
// 				nodes = append(nodes,node.Left)
// 			}
// 		}
// 		res = append(res,str)
// 	}

// 	result := make([][]string,len(res))
// 	for i:=0;i<len(res);i++{
// 		result[i] = make([]string,len(res[len(res)-1]))
// 	}
// 	return result
// }
// func addOneRow(root *TreeNode, val int, depth int) *TreeNode {
// 	if root == nil{
// 		return nil
// 	}
// 	nodes := make([]*TreeNode,0)
// 	cdepth := 1
// 	nodes = append(nodes,root)

// 	for len(nodes) != 0{
// 		n := len(nodes)
// 		if cdepth == depth-1{
// 			for i:=0;i<n;i++{
// 				node := nodes[0]
// 				nodes = nodes[1:]

// 				left := node.Left
// 				right := node.Right
// 				trl := &TreeNode{
// 					Val:val,
// 				}
// 				trr := &TreeNode{
// 					Val:val,
// 				}
// 				trl.Left = left
// 				trr.Right = right
// 				node.Left = trl
// 				node.Right = trr
// 			}
// 			break
// 		}
// 		for i:=0;i<n;i++{
// 			node := nodes[0]
// 			nodes = nodes[1:]
// 			if node.Left != nil{
// 				nodes = append(nodes,node.Left)
// 			}
// 			if node.Right != nil{
// 				nodes = append(nodes,node.Right)
// 			}
// 		}
// 		cdepth++
// 	}

// 	if cdepth != depth -1{
// 		root := &TreeNode{
// 			Val:val,
// 			Left:root,
// 		}
// 		return root
// 	}
// 	return root
// }

// func largestValues(root *TreeNode) []int {
// 	if root == nil{
// 		return nil
// 	}

// 	nodes := make([]*TreeNode,0)
// 	result := make([]int,0)
// 	nodes = append(nodes,root)

// 	for len(nodes) != 0{
// 		n := len(nodes)
// 		res := -(1<<31)
// 		for i:=0;i<n;i++{
// 			node := nodes[0]
// 			nodes = nodes[1:]
// 			if node.Val > res{
// 				res = node.Val
// 			}
// 			if node.Left != nil{
// 				nodes = append(nodes,node.Left)
// 			}
// 			if node.Right != nil{
// 				nodes = append(nodes,node.Right)
// 			}
// 		}
// 		result = append(result,res)
// 	}
// 	return result
// }

// func findBottomLeftValue(root *TreeNode) int {
// 	if root == nil{
// 		return 0
// 	}
// 	nodes := make([]*TreeNode,0)
// 	res := make([]int,0)

// 	nodes = append(nodes,root)

// 	for len(nodes) != 0{
// 		n := len(nodes)
// 		res = res[:0]
// 		for i:=0;i<n;i++{
// 			node := nodes[0]
// 			nodes = nodes[1:]
// 			res = append(res,node.Val)
// 			if node.Left != nil{
// 				nodes = append(nodes,node.Left)
// 				nodes = append(nodes,node.Right)
// 			}
// 		}
// 	}
// 	return res[0]
// }

// func findFrequentTreeSum(root *TreeNode) []int {
// 	resmap := make(map[int]int)
// 	val := computeSum(root,resmap)
// 	resmap[val]++
// 	result := make([]int,0)
// 	m := 0
// 	for i,v := range resmap{
// 		if v > m{
// 			result = result[:0]
// 			result = append(result,i)
//             m = v
// 		}else if v == m{
// 			result = append(result,i)
// 		}
// 	}
// 	return result
// }

// func computeSum(root *TreeNode,resmap map[int]int)int{
// 	if root == nil{
// 		return 0
// 	}
// 	l := computeSum(root.Left,resmap)
// 	r := computeSum(root.Right,resmap)
// 	//resmap[root.Val+l+r]++
// 	resmap[l]++
// 	resmap[r]++
// 	return l+r+root.Val
// }

// type Codec struct {
//     frontnums []int
// 	middlenums []int
// }

// func Constructor() Codec {
//     return Codec{
// 		frontnums: make([]int,0),
// 		middlenums: make([]int,0),
// 	}
// }

// // Serializes a tree to a single string.
// func (this *Codec) serialize(root *TreeNode) string {
//     var reverseSerial func(root *TreeNode) ([]int,[]int)
// 	reverseSerial = func(root *TreeNode)([]int,[]int){
// 		if root == nil{
// 			return nil,nil
// 		}
// 		frontres := make([]int,0)
// 		middleres := make([]int,0)
// 		fl,fm := reverseSerial(root.Left)
// 		rl,rm := reverseSerial(root.Right)
// 		frontres =append(frontres,root.Val)
// 		frontres = append(frontres,fl...)
// 		frontres = append(frontres,rl...)

// 		middleres = append(middleres,fm...)
// 		middleres = append(middleres,root.Val)
// 		middleres = append(middleres,rm...)

// 		return frontres,middleres
// 	}

// 	front,middle := reverseSerial(root)
// 	this.frontnums = append(this.frontnums,front...)
// 	this.middlenums = append(this.middlenums,middle...)
// 	res := "["
// 	for _,v := range this.frontnums{
// 		res += string(v)+","
// 	}
// 	res = res[:len(res)-1]
// 	res += "]"
// 	return res
// }

// // Deserializes your encoded data to tree.
// func (this *Codec) deserialize(data string) *TreeNode {
//     var reverseDeserial func([]int,[]int) *TreeNode
// 	reverseDeserial = func(front []int,middle []int) *TreeNode{
// 		if len(front) == 0{
// 			return nil
// 		}
// 		root := &TreeNode{}
// 		root.Val = front[0]
// 		index := FindIndex(middle,front[0])
// 		root.Left = reverseDeserial(front[1:index+1],middle[:index])
// 		root.Right = reverseDeserial(front[index+1:],middle[index+1:])
// 		return root
// 	}
// 	root := reverseDeserial(this.frontnums,this.middlenums)
// 	return root
// }

// func FindIndex(middle []int,val int)int{
// 	for i:=0;i<len(middle);i++{
// 		if middle[i] == val{
// 			return i
// 		}
// 	}
// 	return 0
// }
// type NestedIterator struct {
//     vals []int
// }

//  type NestedInteger struct {
//  }

// func Constructor(nestedList []*NestedInteger) *NestedIterator {
//     nes := &NestedIterator{
// 		vals : make([]int,0),
// 	}
// 	res := make([]int,0)
// 	var reverseNested func([]*NestedInteger) []int
// 	reverseNested = func(nestedList []*NestedInteger) []int{
// 		if len(nestedList) == 0{
// 			return nil
// 		}
// 		for i:=0;i<len(nestedList);i++{
// 			res = append(res,reverseNested(nestedList[i])...)
// 		}
// 		return res
// 	}

// }

// func (this *NestedIterator) Next() int {

// }

// func (this *NestedIterator) HasNext() bool {

// }

// func isValidSerialization(preorder string) bool {
// 	n := len(preorder)
// 	slot := 1
// 	for i:=0;i<n;{
// 		if slot == 0{
// 			return false
// 		}
// 		if preorder[i] == ','{
// 			i++
// 		}else if preorder[i] == '#'{
// 			i++
// 			slot--
// 		}else{
// 			for i < n && preorder[i] != ',' {
//                 i++
//             }
// 			slot++
// 		}
// 	}
// 	return slot == 0
// }

// func postorderTraversal(root *TreeNode) []int {
// 	if root == nil{
// 		return nil
// 	}
// 	res := make([]int,0)
// 	left := postorderTraversal(root.Left)
// 	right := postorderTraversal(root.Right)

// 	res = append(res,left...)
// 	res = append(res,right...)
// 	res = append(res,root.Val)
// 	return res
// }
// func preorderTraversal(root *TreeNode) []int {
// 	if root == nil{
// 		return nil
// 	}
// 	res := make([]int,0)
// 	left := preorderTraversal(root.Left)
// 	right := preorderTraversal(root.Right)
// 	res = append(res,root.Val)
// 	res = append(res,left...)
// 	res = append(res,right...)
// 	return res
// }

// func sumNumbers(root *TreeNode) int {
// 	if root == nil{
// 		return 0
// 	}
// 	res := make([]int,0)
// 	var reverseNumber func(*TreeNode,int)
// 	reverseNumber = func(root *TreeNode,val int){
// 		if root.Left == nil && root.Right == nil{
// 			res = append(res,val)
// 			return
// 		}
// 		reverseNumber(root.Left,val*10+root.Val)
// 		reverseNumber(root.Right,val*10+root.Val)
// 	}
// 	result := 0
// 	for _,v := range res{
// 		result += v
// 	}
// 	return result
// }

//func Yu2(vals []int) (int,int){
//	sort.Ints(vals) //从小到大排序
//	num1,num2 := 0,0
//
//	start,end := 0,len(vals)-1
//	for start < end{
//		if vals[end]  == vals[start] * vals[start]{
//			num1 = vals[start]
//			num2 = vals[end]
//			return num1,num2
//		}else if vals[start]*vals[start] < vals[end]{
//			k := end
//			for k > start{
//				if vals[start] * vals[start] == vals[k]{
//					num1 = vals[start]
//					num2 = vals[end]
//					return num1,num2
//				}else if  vals[start] * vals[start] > vals[k]{
//					break
//				}else{
//					k--
//				}
//
//			}
//			start++
//		}else{
//			return -1,-1
//		}
//	}
//	return -1,-1
//}
//type Node struct {
//	Val int
//	Left *Node
//	Right *Node
//	Next *Node
//}
//
//func connect(root *Node) *Node {
//	if root == nil {
//		return nil
//	}
//
//	cur := root //指针
//	for cur != nil {
//		var pre *Node  //前置节点
//		var down *Node //下降节点，节点为下一层的左边第一节点
//		for cur != nil {
//			if cur.Left != nil { //左节点判断
//				if pre != nil {
//					pre.Next = cur.Left //pre不为空 设置Next
//				} else {
//					down = cur.Left //pre为空 设置下降节点
//				}
//				pre = cur.Left //设置前置节点
//			}
//
//			if cur.Right != nil { //右节点判断，同上
//				if pre != nil {
//					pre.Next = cur.Right
//				} else {
//					down = cur.Right
//				}
//				pre = cur.Right
//			}
//			cur = cur.Next //同层移动
//		}
//		cur = down //下降
//	}
//	return root
//}

//func connect(root *Node) *Node {
//	if root == nil{
//		return nil
//	}
//
//	for i := root;i.Left != nil;i = i.Left{
//		for j:=i;j != nil;j=j.Next{
//			if j.Left != nil && j.Right != nil{
//				j.Left.Next = j.Right
//			}
//			if j.Next != nil{
//				if j.Right != nil{
//					if j.Next.Left != nil{
//						j.Right.Next = j.Next.Left
//					}else if j.Next.Right != nil{
//						j.Right.Next = j.Next.Right
//					}
//				}else if j.Left != nil{
//					if j.Next.Left != nil{
//						j.Left.Next = j.Next.Left
//					}else if j.Next.Right != nil{
//						j.Left.Next = j.Next.Right
//					}
//				}
//				if j.Next.Left != nil && j.Next.Right != nil{
//					j.Next.Left.Next  = j.Next.Right
//				}
//			}
//		}
//	}
//	return root
//}

//func connect(root *Node) *Node {
//	if root == nil{
//		return nil
//	}
//
//	nodes := make([]*Node,0)
//	nodes = append(nodes,root)
//
//	for len(nodes) > 0{
//		l := len(nodes)
//		for i:=0;i<l;i++{
//			if i != l-1{
//				nodes[i].Next = nodes[i+1]
//			}
//			if nodes[i].Left != nil{
//				nodes = append(nodes,nodes[i].Left)
//			}
//			if nodes[i].Right != nil{
//				nodes = append(nodes,nodes[i].Right)
//			}
//		}
//		nodes = nodes[l:]
//	}
//	return root
//}
//func pathSum(root *TreeNode, targetSum int) [][]int {
//	var reversePathSum func(*TreeNode,[]int,int,bool)
//	result := make([][]int,0)
//
//	reversePathSum = func(root *TreeNode,vals []int,sum int,flag bool){
//		if root == nil{
//			if sum == targetSum && flag{
//				result = append(result,append([]int(nil),vals...))
//			}
//			return
//		}
//		vals = append(vals,root.Val)
//		sum += root.Val
//		if root.Left == nil && root.Right == nil{
//			reversePathSum(root.Left,vals,sum,true)
//		}else{
//			reversePathSum(root.Left,vals,sum,false)
//			reversePathSum(root.Right,newvals,sum,false)
//		}
//
//
//	}
//
//	vals := make([]int,0)
//	if root.Left == nil && root.Right == nil{
//		reversePathSum(root,vals,0,true)
//	}else{
//		reversePathSum(root,vals,0,false)
//	}
//
//	return result
//}

//
// type ListNode struct {
//	     Val int
//	     Next *ListNode
//	 }
//
//
//
//func sortedListToBST(head *ListNode) *TreeNode {
//	var reverseSorted func([]int) *TreeNode
//	reverseSorted = func(nodes []int) *TreeNode{
//		if len(nodes) == 0{
//			return nil
//		}
//		mid := len(nodes)/2
//		root := &TreeNode{Val: nodes[mid]}
//		if mid+1 < len(nodes){
//			root.Right = reverseSorted(nodes[mid+1:])
//		}else{
//			root.Right = nil
//		}
//
//		root.Left = reverseSorted(nodes[:mid])
//
//		return root
//	}
//	vals := make([]int,0)
//	for head != nil{
//		vals = append(vals,head.Val)
//		head = head.Next
//	}
//	root := reverseSorted(vals)
//	return root
//
//}
//

//func buildTree(inorder []int, postorder []int) *TreeNode {
//	if len(inorder) == 0{
//		return nil
//	}
//	node := &TreeNode{}
//	rootval := postorder[len(postorder)-1]
//	postorder = postorder[:len(postorder)-1]
//	index := FindIndex(inorder,rootval)
//
//	node.Val = rootval
//	node.Left = buildTree(inorder[:index],postorder[:index])
//	node.Right = buildTree(inorder[index+1:],postorder[index:])
//	return node
//}
//func FindIndex(inorder []int,val int) int{
//	for i:=0;i<len(inorder);i++{
//		if inorder[i] == val{
//			return i
//		}
//	}
//	return -1
//}

//func mostCommonWord(paragraph string, banned []string) string {
//	s := strings.Split(paragraph, " ")
//	indexs := make(map[string]int)
//	for i:=0;i<len(banned);i++{
//		indexs[banned[i]]++
//	}
//	resm := make(map[string]int)
//	for i:=0;i<len(s);i++{
//		if _,ok := indexs[s[i]];ok{
//			continue
//		}
//		resm[s[i]]++
//	}
//	res,index := -1,""
//	for i,v := range{
//		if v > res{
//			index = i
//		}
//	}
//	return index
//}

//func numberOfLines(widths []int, s string) []int {
//	result := make([]int,2)
//	slen := 0
//	for i:=0;i<len(s);i++{
//		if slen + widths[s[i]-'a'] > 100{
//			slen = widths[s[i]]-'a'
//			result[0]++
//		}
//	}
//	result[1] = slen
//	return result
//}
//func rotateString(s string, goal string) bool {
//	if len(s) != len(goal){
//		return false
//	}else if s == goal{
//		return true
//	}
//
//	for i:=0;i<len(s);i++{
//		if s[i] == goal[0]{
//			news := s[i:]+s[:i]
//			if news == goal{
//				return true
//			}
//		}
//	}
//	return false
//}
//func minDiffInBST(root *TreeNode) int {
//	var verserMinDiff func(root *TreeNode) []int
//	//result := make([]int,0)
//	verserMinDiff = func(root *TreeNode) []int{
//		if root == nil{
//			return nil
//		}
//		result := make([]int,0)
//		left := verserMinDiff(root.Left)
//		right := verserMinDiff(root.Right)
//		result = append(left,root.Val)
//		result = append(result,right...)
//		return result
//	}
//	res := verserMinDiff(root)
//	result := 1<<21
//	for i:=1;i<len(res);i++{
//		if res[i] - res[i-1] < result{
//			result = res[i] - res[i-1]
//		}
//	}
//	return result
//
//}

//func numJewelsInStones(jewels string, stones string) int {
//	jmap := make(map[byte]int)
//	for i:=0;i<len(jewels);i++{
//		jmap[jewels[i]]++
//	}
//	res := 0
//	for i:=0;i<len(stones);i++{
//		if _,ok := jmap[stones[i]];ok{
//			res++
//		}
//	}
//	return res
//}

//func isToeplitzMatrix(matrix [][]int) bool {
//	for i:=0;i<len(matrix);i++{
//		for j:=0;j<len(matrix[0]);j++{
//			if i+1 < len(matrix) && j+1<len(matrix[0]){
//				 if matrix[i+1][j+1] != matrix[i][j]{
//				 	return false
//				 }
//			}
//		}
//	}
//	return true
//}

//func dominantIndex(nums []int) int {
//	if len(nums) == 1{
//		return 0
//	}
//	max1:=-1
//	max2:=-1
//	index:=-1
//	for i,v:=range nums{
//		if v > max1{
//			max2=-max1
//			max1=v
//			index=i
//		}else if v > max2{
//			max2=v
//		}
//	}
//	if max1 >= 2 * max2{
//		return index
//	}
//	return -1
//
//}

//
//func dominantIndex(nums []int) int {
//	indexs := make([]int,3)
//	indexs[1] = -1
//	for i:=0;i<len(nums);i++{
//		if nums[i] > indexs[0] {
//			indexs[0] = nums[i]
//			if indexs[0] >= indexs[1]{
//				indexs[1] = nums[i] * 2
//			}
//			indexs[2] = i
//		}
//	}
//	if indexs[0] * 2 != indexs[1]{
//		return -1
//	}
//	return indexs[2]
//}
//func minCostClimbingStairs(cost []int) int {
//	n := len(cost)
//	temp := make([]int,n+1)
//	for i:=2;i<=n;i++{
//		temp[i] = min(temp[i-1]+cost[i-1],temp[i-2]+cost[i-2])
//	}
//	return temp[n]
//}

//
//func nextGreatestLetter(letters []byte, target byte) byte {
//	if target > letters[len(letters)-1]{
//		return letters[0]
//	}else{
//		for i:=0;i<len(letters);i++{
//			if letters[i] > target{
//				return letters[i]
//			}
//		}
//	}
//	return 'a'
//}

//func selfDividingNumbers(left int, right int) []int {
//	result := make([]int,0)
//
//	for i:=left;i<=right;i++{
//		kv := Sumdivide(i)
//		if !kv{
//			continue
//		}
//		result = append(result,i)
//	}
//	return result
//}
//
//func Sumdivide(num int) bool {
//	res := make([]int,0)
//	temp := num
//	for num != 0{
//		if nums := num  % 10;nums != 0{
//			if temp % nums != 0{
//				return false
//			}
//			num /= 10
//		}else{
//			return false
//		}
//
//	}
//	return true
//}

//f
//unc pivotIndex(nums []int) int {
//	left,right := 0,0
//
//	for i:=1;i<len(nums);i++{
//		right +=nums[i]
//	}
//
//	for i:=0;i<len(nums);i++{
//		if i == 0{
//			if left == right{
//				return i
//			}
//			continue
//		}
//		left += nums[i-1]
//		right -= nums[i]
//		if left == right{
//			return i
//		}
//
//	}
//	return -1
//}

//func longestWord(words []string) string {
//
//	hashMap:=map[string]int{}
//	sort.Strings(words)
//	fmt.Println(words)
//	result:=""
//	for _,word:=range words {
//
//		if len(word) == 1 {
//			hashMap[word]++
//			if len(result) == 0 {
//				result = word
//			}
//			continue
//		}
//
//		if _,ok := hashMap[word[0:len(word)-1]];ok {
//			hashMap[word]++
//			if  len(result) < len(word) {
//				result = word
//			}
//		}
//
//	}
//	return result
//}

//func isOneBitCharacter(bits []int) bool {
//	if bits[len(bits)-1] != 0{
//		return false
//	}
//
//	for i:=0;i<len(bits);{
//		if bits[i] == 1{
//			i+=2
//
//		}else{
//			i+=1
//
//		}
//		if i == len(bits)-1{
//			return true
//		}
//	}
//	return false
//}

//func toLowerCase(s string) string {
//	sbyte := []byte(s)
//	fmt.Println(sbyte)
//	for i:=0;i<len(sbyte);i++{
//		if sbyte[i] - 32 < 65{
//			sbyte[i] = sbyte[i] + 32
//		}
//	}
//	return string((sbyte))
//}

//type MyHashMap struct {
//	indexs map[int]int
//}
//
//
///** Initialize your data structure here. */
//func Constructor() MyHashMap {
//	k := MyHashMap{
//		indexs: make(map[int]int),
//	}
//	return k
//}
//
//
///** value will always be non-negative. */
//func (this *MyHashMap) Put(key int, value int)  {
//	this.indexs[key] = value
//}
//
//
///** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
//func (this *MyHashMap) Get(key int) int {
//	if k,ok := this.indexs[key];ok{
//		return k
//	}
//	return -1
//}
//
//
///** Removes the mapping of the specified value key if this map contains a mapping for the key */
//func (this *MyHashMap) Remove(key int)  {
//	if _,ok := this.indexs[key];ok{
//		delete(this.indexs,key)
//	}
//
//}

//type MyHashSet struct {
//	indexs map[int]int
//}
//
//
///** Initialize your data structure here. */
//func Constructor() MyHashSet {
//	k := MyHashSet{
//		indexs: make(map[int]int),
//	}
//	return k
//}
//
//
//func (this *MyHashSet) Add(key int)  {
//	this.indexs[key] = 0
//}
//
//
//func (this *MyHashSet) Remove(key int)  {
//	if _,ok := this.indexs[key];ok{
//		delete(this.indexs,key)
//	}
//}
//
//
///** Returns true if this set contains the specified element */
//func (this *MyHashSet) Contains(key int) bool {
//	if _,ok := this.indexs[key];ok{
//		return true
//	}
//	return false
//}

//type KthLargest struct {
//	sort.IntSlice
//	k int
//}
//
//func Constructor(k int, nums []int) KthLargest {
//	kl := KthLargest{k: k}
//	for _, val := range nums {
//		kl.Add(val)
//	}
//	return kl
//}
//
//func (kl *KthLargest) Push(v interface{}) {
//	kl.IntSlice = append(kl.IntSlice, v.(int))
//}
//
//func (kl *KthLargest) Pop() interface{} {
//	a := kl.IntSlice
//	v := a[len(a)-1]
//	kl.IntSlice = a[:len(a)-1]
//	return v
//}
//
//func (kl *KthLargest) Add(val int) int {
//	heap.Push(kl, val)
//	if kl.Len() > kl.k {
//		heap.Pop(kl)
//	}
//	return kl.IntSlice[0]
//}

//type short struct{
//	count int
//	left int
//	right int
//}
//
//func searchBST(root *TreeNode, val int) *TreeNode {
//	if root == nil{
//		return nil
//	}
//	if root.Val == val{
//		return root
//	}
//	left := searchBST(root.Left,val)
//	right := searchBST(root.Right,val)
//	if left != nil{
//		return left
//	}else if right != nil{
//		return right
//	}
//	return nil
//}

//func findShortestSubArray(nums []int) int {
//	if len(nums) == 0{
//		return 1
//	}
//	indexs := make(map[int]*short)
//	maxcount := 0
//	for i:=0;i<len(nums);i++{
//		if k,exit := indexs[nums[i]];exit{
//			k.count++
//			k.right = i
//		}else{
//			s := &short{
//				count:1,
//				left:i,
//			}
//			indexs[nums[i]] = s
//		}
//		if indexs[nums[i]].count > maxcount{
//			maxcount = indexs[nums[i]].count
//		}
//	}
//	minres := 1 << 32
//	for i,v := range indexs{
//		if v.count == maxcount{
//			if minres < v.right - v.left + 1{
//				minres = v.right - v.left + 1
//			}
//		}
//	}
//	return minres
//}

//func countBinarySubstrings(s string) int {
//	indexs := make([]int,0)
//	k := 0
//	for k < len(s){
//		count := 0
//		pre := s[k]
//		for k < len(s) && s[k] == pre{
//			count++
//			k++
//		}
//		indexs = append(indexs,count)
//	}
//	ans := 0
//	for i:=1;i<len(indexs);i++{
//		ans += min(indexs[i],indexs[i-1])
//	}
//	return ans
//}

//func hasAlternatingBits(n int) bool {
//	inx := n & 1
//	n = n >> 1
//	i := 0
//	for n != 0{
//		if n >> i & 1 == inx{
//			return false
//		}else{
//			inx = n >> i & 1
//			n = n >> 1
//		}
//	}
//	return true
//}

//func getImportance(employees []*Employee, id int) int {
//
//
//}
//
//func getImportance(employees []*Employee, id int) (total int) {
//	mp := map[int]*Employee{}
//	for _, employee := range employees {
//		mp[employee.Id] = employee
//	}
//
//	var dfs func(int)
//	dfs = func(id int) {
//		employee := mp[id]
//		total += employee.Importance
//		for _, subId := range employee.Subordinates {
//			dfs(subId)
//		}
//	}
//	dfs(id)
//	return
//}
//
//func calPoints(ops []string) int {
//	if len(ops) == 0{
//		return 0
//	}
//	res := make([]int,0)
//	for i:=0;i<len(ops);i++{
//		k,err:= strconv.ParseInt(ops[i],10,64)
//		if err != nil{
//			res = append(res,int(k))
//			continue
//		}
//		if ops[i] == "+"{
//			num1,num2 := res[len(res)-1],res[len(res)-2]
//			res = res[:len(res)-2]
//			res = append(res,num1+num2)
//		}else if ops[i] == "D"{
//			res = append(res,res[len(res)-1] * 2)
//		}else if ops[i] == "C"{
//			res = res[:len(res)-1]
//		}
//	}
//	result := 0
//	for i:=0;i<len(res);i++{
//		result += res[i]
//	}
//	return result
//}

//func main() {
//	s := "aguokepatgbnvfqmgmlcupuufxoohdfpgjdmysgvhmvffcnqxjjxqncffvmhvgsymdjgpfdhooxfuupuculmgmqfvnbgtapekouga"
//	k := validPalindrome(s)
//	fmt.Println(k)
//
//}
//
//func validPalindrome(s string) bool {
//	flag1,flag2 := true,true
//	start,end := 0,len(s)-1
//	for start < end && start < len(s) && end >=0{
//		if s[start] != s[end]{
//				for i,j := start+1,end;i < j;i,j = i+1,j-1{
//					if s[i] != s[j]{
//						flag1 = false
//						break
//					}
//				}
//				for i,j := start,end-1;i < j;i,j = i+1,j-1{
//					if s[i] != s[j]{
//						flag2 = false
//						break
//					}
//				}
//				return flag1 || flag2
//		}
//		start++
//		end--
//	}
//	return true
//}

//func findLengthOfLCIS(nums []int) int {
//	start := 0
//	res := 0
//	for i,v := range nums{
//		if i > 0 && v <= nums[i-1]{
//			start = i
//		}
//		res = max(res,i-start+1)
//	}
//	return res
//}

//func judgeCircle(moves string) bool {
//
//	indexs := [][]int{{0,1},{0,-1},{1,0},{-1,0}}
//	k := []int{0,0}
//	for i:=0;i<len(moves);i++{
//		if moves[i] == 'R'{
//			k[0] += indexs[0][0]
//			k[1] += indexs[0][1]
//		}else if moves[i] == 'L'{
//			k[0] += indexs[1][0]
//			k[1] += indexs[1][1]
//		}else if moves[i] == 'U'{
//			k[0] += indexs[2][0]
//			k[1] += indexs[2][1]
//		}else{
//			k[0] += indexs[3][0]
//			k[1] += indexs[3][1]
//		}
//	}
//	if k[0] == 0 && k[1] == 0{
//		return true
//	}
//	return false
//}

//func findTarget(root *TreeNode, k int) bool {
//	var reverseFind func(root *TreeNode)
//	indexs := make(map[int]bool)
//	reverseFind = func(root *TreeNode){
//		if root == nil{
//			return
//		}
//		indexs[root.Val] = true
//		reverseFind(root.Left)
//		reverseFind(root.Right)
//	}
//	reverseFind(root)
//	for i,v := range indexs{
//		if _,ok := indexs[k-i];ok{
//			return true
//		}
//	}
//	return false
//}
//
//func findTarget(root *TreeNode, k int) bool {
//
//}
//func findMaxAverage(nums []int, k int) float64 {
//	res := 0
//	for i:=0;i<k;i++{
//		res += nums[i]
//	}
//	maxnum := float64(res)/float64(k)
//
//	for i:=k;i<len(nums);i++{
//		res = res - nums[i-k] + nums[i]
//		if maxnum < float64(res) / float64(k){
//			maxnum = float64(res) / float64(k)
//			//fmt.Println(res,maxnum,i,nums[i-k],nums[i])
//		}
//	}
//	return maxnum
//}
//
//
//func averageOfLevels(root *TreeNode) []float64 {
//	if root == nil{
//		return nil
//	}
//	res := make([]int,0)
//	nodes := make([]*TreeNode,0)
//	nodes = append(nodes,root)
//	result := make([]float64,0)
//	for len(nodes) != 0{
//		n := len(nodes)
//		for i:=0;i<n;i++{
//			node := nodes[0]
//			nodes = nodes[1:]
//			res = append(res,node.Val)
//
//			if node.Left != nil{
//				nodes = append(nodes,node.Left)
//			}
//			if node.Right != nil{
//				nodes = append(nodes,node.Right)
//			}
//		}
//		r := 0
//		for i:=0;i<len(res);i++{
//			r+=res[i]
//		}
//		result = append(result,float64(r)/float64(len(res)))
//		res = res[:0]
//	}
//	return result
//}

//
//func tree2str(root *TreeNode) string {
//	res := ""
//	var reverseTree func(root *TreeNode)
//
//	reverseTree = func(root *TreeNode) {
//		if root == nil{
//			return
//		}
//		res += "(" + string(root.Val)
//		reverseTree(root.Left)
//		res += ")"
//		res += "("
//		reverseTree(root.Right)
//		res+=")"
//	}
//}

//func canPlaceFlowers(flowerbed []int, n int) bool {
//	for i:=0;i<len(flowerbed);{
//		if flowerbed[i] == 1{
//			i+=2
//
//		}else if flowerbed[i] == 0{
//			if i+1 < len(flowerbed) && flowerbed[i+1] == 0{
//				n--
//				flowerbed[i+1] = 1
//				i+=2
//			}else if i+1 == len(flowerbed){
//				n--
//				i++
//			}else{
//				i+=3
//			}
//		}
//	}
//	if n == 0{
//		return true
//	}
//	return false
//}

//func findRestaurant(list1 []string, list2 []string) []string {
//	list1m := make(map[string]int)
//	list2m := make(map[string]int)
//	//res := make([]string,0)
//	resindex := make(map[int][]string)
//	for i:=0;i<len(list1);i++{
//		list1m[list1[i]] = i
//	}
//	for i:=0;i<len(list2);i++{
//		list2m[list2[i]] = i
//	}
//	for i,v := range list1m{
//		if k,ok := list2m[i];ok{
//			resindex[v+k] = append(resindex[v+k],i)
//		}
//	}
//	min1 := 1 << 32
//	for i,_ := range resindex{
//		if i < min1{
//			min1 = i
//		}
//	}
//	return resindex[min1]
//}

//func maxCount(m int, n int, ops [][]int) int {
//	x,y := m,n
//	for i:=0;i<len(ops);i++{
//		if ops[i][0] < x{
//			x = ops[i][0]
//		}
//		if ops[i][1] < y{
//			y = ops[i][1]
//		}
//	}
//	return x * y
//
//}

//func findLHS(nums []int) int {
//	sort.Ints(nums)
//	maxq := 1
//
//	j:=0
//	for i:=0;i<len(nums);i++{
//		if nums[i+maxq] - nums[i] > 1{
//			break
//		}
//		for j =i+1;j<len(nums);j++{
//			if nums[j] - nums[i] == 1{
//				continue
//			}
//			maxq = max(maxq,j - i)
//		}
//		maxq = max(maxq,j - i)
//	}
//	return maxq
//}

//func postorder(root *Node) []int {
//	if root == nil{
//		return nil
//	}
//	result := make([]int,0)
//
//	var reserPreorder func(root *Node)
//	reserPreorder = func(root *Node) {
//		if root == nil{
//			return
//		}
//		if len(root.Children) != 0{
//			reserPreorder(root.Children[0])
//			for i:=1;i<len(root.Children);i++{
//				reserPreorder(root.Children[i])
//			}
//		}
//		result = append(result,root.Val)
//	}
//
//	reserPreorder(root)
//	return result
//}
//func preorder(root *Node) []int {
//	if root == nil{
//		return nil
//	}
//	result := make([]int,0)
//
//	var reserPreorder func(root *Node)
//	reserPreorder = func(root *Node) {
//		if root == nil{
//			return
//		}
//		result = append(result,root.Val)
//		if len(root.Children) != 0{
//			reserPreorder(root.Children[0])
//			for i:=1;i<len(root.Children);i++{
//				reserPreorder(root.Children[i])
//			}
//		}
//	}
//
//	reserPreorder(root)
//	return result
//}

//func distributeCandies(candies []int) int {
//	var candiesMap map[int]bool
//	candiesMap = make(map[int]bool)
//	var candiesCount = 0
//	for i := 0; i < len(candies); i++ {
//		candie := candies[i]
//		_, ok := candiesMap[candie]
//		// candie 不存在，开始计数
//		if !ok {
//			candiesMap[candie] = true
//			candiesCount += 1
//		}
//	}
//	var each = len(candies) / 2
//	if candiesCount >= each {
//		return each
//	} else {
//		return candiesCount
//	}
//}

//TODO:判断一颗树是否包含另一颗树可以深度遍历每个节点去判断是否一致
//func isSubtree(s *TreeNode,t *TreeNode) bool{
//	if s == nil{
//		return false
//	}
//	return check(s,t) || isSubtree(s.Left,t) || isSubtree(s.Right,t)
//}
//
//func check(a,b *TreeNode) bool{
//	if a== nil && b == nil{
//		return true
//	}
//	if a == nil || b == nil{
//		return false
//	}
//	if a.Val == b.Val{
//		return check(a.Left,b.Left) && check(a.Right,b.Right)
//	}
//	return false
//}

//func isSubtree(root *TreeNode, subRoot *TreeNode) bool {
//	var reversSubtree func(root *TreeNode,subRoot *TreeNode,sub *TreeNode) bool
//
//	reversSubtree = func(root *TreeNode,subRoot *TreeNode,sub *TreeNode) bool{
//		if sub == nil{
//			return true
//		}else if root == nil && sub != nil {
//			return false
//		}
//
//		lb,rb := false,false
//		lb1,rb1 := false,false
//		if  root.Val != sub.Val{
//			lb = reversSubtree(root.Left,subRoot,subRoot)
//			rb = reversSubtree(root.Right,subRoot,subRoot)
//		}else{
//			lb1 = reversSubtree(root.Left,subRoot,sub.Left)
//			rb1 = reversSubtree(root.Right,subRoot,sub.Right)
//		}
//		if lb || rb || lb1 && rb1{
//			return true
//		}
//		return false
//	}
//	return reversSubtree(root,subRoot,subRoot)
//}

//func matrixReshape(mat [][]int, r int, c int) [][]int {
//	if len(mat) == 0{
//		return nil
//	}else if len(mat[0]) == 0{
//		return nil
//	}
//	cow,lenm := len(mat),len(mat[0])
//	newmat := make([][]int,r)
//
//	for i:=0;i<r;i++{
//		newmat[i] = make([]int,c)
//	}
//	mi,mj := 0,0
//	for i:=0;i<r;i++{
//		for j:=0;i<c;j++{
//			newmat[i][j] = mat[mi][mj]
//			if mj == lenm-1{
//				mj=0
//				mi++
//			}
//		}
//	}
//	return newmat
//}

//func findTilt(root *TreeNode) int {
//	res := make([]int,0)
//	var reverseFind func(root *TreeNode) int
//	reverseFind = func(root *TreeNode) int {
//		if root == nil{
//			return 0
//		}
//		lval := reverseFind(root.Left)
//		rval := reverseFind(root.Right)
//		if lval - rval > 0{
//			res = append(res,lval-rval)
//		}else{
//			res = append(res,rval-lval)
//		}
//		return lval+rval+root.Val
//	}
//	reverseFind(root)
//	result := 0
//	for i:=0;i<len(res);i++{
//		result += res[i]
//	}
//	return result
//}

//func arrayPairSum(nums []int) int {
//	res := 0
//	sort.Ints(nums)
//	for i:=0;i<len(nums);i+=2{
//		res+=nums[i]
//	}
//	return res
//}

// type Node struct {
//	     Val int
//	     Children []*Node
// }
//func maxDepth(root *Node) int {
//	if root == nil{
//		return 0
//	}
//	res := make([]int,len(root.Children))
//	for i:=0;i<len(root.Children);i++{
//		res = append(res,maxDepth(root.Children[i]))
//	}
//	sort.Ints(res)
//	return res[len(res)-1]
//}

//func checkRecord(s string) bool {
//	indes := "ALP"
//
//	flagL := 0
//	flagA := 0
//	flag := []int{0,0}
//	for i:=0;i<len(s);i++{
//		if s[i] == indes[1]{
//			flagL++
//		}else if s[i] == indes[0]{
//			flagA++
//			if flagL > 0{
//				flagL--
//			}
//		}else{
//			if flag > 0{
//				flagL--
//			}
//		}
//		if flagL == 3{
//			flag[0] = 1
//		}
//		if flagA == 2{
//			flag[1] = 1
//		}
//	}
//	if flag[0] == 1 && flag[1] == 1{
//		return false
//	}
//	return true
//}

//func findWords(words []string) []string {
//	indexs := make([]map[byte]int,3)
//	indexs[0] = make(map[byte]int)
//
//}

//func findLUSlength(a string, b string) int {
//	amap := make(map[int])
//}
//
//func reverseStr(s string, k int) string {
//	t := []byte(s)
//	for i:=0;i<len(s);i+=2*k{
//		sub := t[i:min(i+k,len(s))]
//		for j,n := 0,len(sub);j<n/2;j++{
//			sub[j],sub[n-j-1] = sub[n-j-1],sub[j]
//		}
//	}
//	return string(t)
//}

//func getMinimumDifference(root *TreeNode) int {
//	ans, pre := math.MaxInt64, -1
//	var dfs func(*TreeNode)
//	dfs = func(node *TreeNode) {
//		if node == nil {
//			return
//		}
//		dfs(node.Left)
//		if pre != -1 && node.Val-pre < ans {
//			ans = node.Val - pre
//		}
//		pre = node.Val
//		dfs(node.Right)
//	}
//	dfs(root)
//	return ans
//
//}
//func detectCapitalUse(word string) bool {
//	flag := false
//	if len(word) == 0{
//		return true
//	}
//	if word[0] <= 'Z' && word[0] >='A'{
//		flag = true
//	}
//	for i := 1;i<len(word);i++{
//		if flag && i>1{
//			if word[i] > 'Z' && word[i-1] <'Z' || word[i] < 'Z' && word[i-1] > 'Z'{
//				return false
//			}
//		}else if !flag{
//			if word[i] <'Z'{
//				return false
//			}
//		}
//	}
//	return true
//}

//func checkPerfectNumber(num int) bool {
//	res := make([]int,0)
//	for i:=2;i<=int(math.Sqrt(float64(num)));i++{
//		if num % i == 0{
//			res = append(res,i)
//			res = append(res,num / i)
//		}
//	}
//	fmt.Println(res)
//	k := 0
//	for _,v := range res{
//		k=k+v
//	}
//	if k+1 == num{
//		return true
//	}
//	return false
//}

//func findRelativeRanks(score []int) []string {
//	indexs := []string{"Gold Medal", "Silver Medal", "Bronze Medal"}
//	res := make([]string,len(score))
//
//	for i:=0;i<len(score);i++{
//		if i < 3{
//			res[i] = indexs[i]
//			continue
//		}
//		res[i] = strconv.FormatInt(int64(i-2),10)
//
//	}
//	return res
//}

//func convertToBase7(num int) string {
//	res := ""
//
//	for num < 7{
//		res = strconv.FormatInt(int64(num%7),7) + res
//		num = num / 7
//	}
//	res = strconv.FormatInt(int64(num),7) + res
//	return res
//}

//func findMode(root *TreeNode) []int {
//	nums := make(map[int]int)
//	var reverseFind func(root *TreeNode)
//	reverseFind = func(root *TreeNode){
//		if root == nil{
//			return nli
//		}
//		nums[root.Val]++
//		reverseFind(root.Left)
//		reverseFind(root.Right)
//	}
//	res := make([]int,0)
//	maxcount := 0
//
//	for i,v := range nums{
//		if v > maxcount{
//			maxcount = v
//			res = res[:0]
//			res = append(res,i)
//		}else if v == maxcount{
//			res = append(res,i)
//		}
//	}
//	return res
//}

//func nextGreaterElement(nums1 []int, nums2 []int) []int {
//	indexs := make(map[int]int)
//	for i:=0;i<len(nums);i++{
//		indexs[nums2[i]]= i
//	}
//	res := make([]int,len(nums1))
//	flag := false
//	for i:=0;i<len(nums1);i++{
//		index := indexs[nums1[i]]
//		for j:=index+1;j<len(nums2);j++{
//			if nums2[j] > nums1[i]{
//				res = append(res,nums2[j])
//				flag = true
//				break
//			}
//		}
//		if !flag {
//			flag = false
//			res = append(res,-1)
//		}
//
//	}
//	return res
//}

//func findPoisonedDuration(timeSeries []int, duration int) int {
//	waster := 0
//	for i:=0;i<len(timeSeries);i++{
//		if timeSeries[i] - timeSeries[i-1]  < duration{
//			waster += timeSeries[i-1] + duration - timeSeries[i]
//		}
//	}
//	return len(timeSeries)*duration - waster
//}

//func findMaxConsecutiveOnes(nums []int) int {
//	res := 0
//	tmp := 0
//
//	for i:= 0;i<len(nums);i++{
//		if nums[i] == 1{
//			tmp++
//		}else{
//			res = max(res,tmp)
//			tmp = 0
//		}
//	}
//	return res
//}

//func licenseKeyFormatting(s string, k int) string {
//	result := ""
//
//	res := ""
//	for i:= len(s)-1;i>=0;i--{
//		if s[i] != '-'{
//			res = strings.ToUpper(string(s[i])) + res
//		}
//		if len(res) == k{
//			result = "-" + res + result
//			res = ""
//		}
//	}
//	if len(res) != 0{
//		result = res + result
//	}else{
//		result = result[1:]
//	}
//	return result
//}

//func findComplement(num int) int {
//	ans := 0
//	index := 0
//	for num != 0{
//		ans = ans + (num ^ 1) << index
//		num >>= 1
//		index++
//
//	}
//	return ans
//}

//func islandPerimeter(grid [][]int) int {
//	if len(grid) == 0 || len(grid[0]) == 0{
//		return 0
//	}
//	res := 0
//	idnexs := [][]int{{-1,0},{1,0},{0,-1},{0,1}}
//	for i:=0;i<len(grid);i++{
//		for j:=0;j<len(grid[0]);j++{
//			if grid[i][j] == 1 && (i == 0 || i == len(grid)-1){
//				res++
//			}
//
//			if grid[i][j] == 1 && (j == 0 || j == len(grid[0])-1){
//				res++
//			}
//			if grid[i][j] == 0{
//				for _,v := range idnexs{
//					if i + v[0] >= 0 && i + v[0] < len(grid) && grid[i+v[0]][j] == 1{
//						res++
//					}
//					if j + v[1] >= 0 && j+v[1] < len(grid[0]) && grid[i][j+v[1]] == 1{
//						res++
//					}
//				}
//			}
//			fmt.Println(res)
//		}
//	}
//	return res
//}

//func repeatedSubstringPattern(s string) bool {
//	n := len(s)
//	for i:=1;i * 2 <= n;i++{
//		if n % i == 0 {
//			match := true
//			for j:=1;j<n;j++{
//				if s[j] != s[j-i]{
//					match = false
//					break
//				}
//			}
//			if match{
//				return true
//			}
//
//		}
//	}
//	return false
//}

//func findContentChildren(g []int, s []int) int {
//	l1 := 0
//	l2 := 0
//	res := 0
//	for l2 < len(s){
//		if s[l2] >= g[l1]{
//			res++
//			l1++
//			l2++
//		}
//		l2++
//	}
//	return res
//}

//func minMoves(nums []int) int {
//	res,min1 := 0,1 << 32
//	for i:=0;i<len(nums);i++{
//		min1 = min(min1,nums[i])
//	}
//	for i:=0;i<len(nums);i++{
//		res += nums[i] - min1
//	}
//	return res
//}

//func countSegments(s string) int {
//	count := 0
//	for i:=0;i<len(s);i++{
//		if (i == 0 || s[i-1] == ' ') && s[i] !=' '{
//			count++
//		}
//	}
//	return count
//}

//func addStrings(num1 string, num2 string) string {
//	n :=0
//	if len(num1) > len(num2){
//		n = len(num1)
//	}else{
//		n = len(num2)
//	}
//	for i:=0;i
//}

//func thirdMax(nums []int) int {
//	sort.Ints(nums)
//
//	if len(nums) < 3{
//		return nums[len(nums)-1]
//	}
//	idnex := 1
//	for i:= len(nums)-2;i>=0;i--{
//		if nums[i] != nums[i+1]{
//			idnex++
//		}
//		if idnex == 3{
//			return nums[i]
//		}
//	}
//	return nums[0]
//}

//func longestPalindrome(s string) int {
//	indexs := make(map[byte]int)
//	res := 0
//	max := 0
//
//	for i:=0;i<len(s);i++{
//		indexs[s[i]]++
//	}
//	for i,v := range indexs{
//		if v % 2 == 0{
//			res+=2
//		}else if v > max{
//			if max == 0{
//				res = res  + v
//			}else{
//				res = res -1 + v
//			}
//
//			max = v
//			strconv.FormatInt()
//		}
//	}
//	return res
//}

//func isSubsequence(s string, t string) bool {
//	index := 0
//	for i:=0;i<len(t);i++{
//		if t[i] == s[index]{
//			index++
//		}
//		if index == len(s){
//			return true
//		}
//	}
//	if index == len(s){
//		return true
//	}
//	return false
//
//}

//func toHex(num int) string {
//	if num == 0{
//		return "0"
//	}
//	helper := "0123456789abcdef"
//	ans :=""
//	for num != 0 && len(ans) < 8{
//		temp := num & 15
//		ans = string(helper[temp])+ans
//		num >>=4
//	}
//	return ans
//}

//func sumOfLeftLeaves(root *TreeNode) int {
//	result := 0
//	var sumLeftreverse func(root *TreeNode,yp bool)
//	sumLeftreverse = func(root *TreeNode,yp bool){
//		if root == nil{
//			return
//		}
//		if root.Left == nil && root.Right == nil && yp{
//			result += root.Val
//		}
//		sumLeftreverse(root.Left,true)
//		sumLeftreverse(root.Right,false)
//	}
//	sumLeftreverse(root,false)
//	return result
//}

//func guessNumber(n int) int {
//	start := 0
//	end := n
//
//	for start + 1 < end{
//		mid := (start + end)/2
//		if guess(mid) == 0{
//			return mid
//		}else if guess(mid) < 0{
//			end = mid
//		}else{
//			start = mid
//		}
//	}
//	if guess(start) == 0{
//		return start
//	}
//	return end
//}

//func intersect(nums1 []int, nums2 []int) []int {
//	index1 := make(map[int]int)
//	result := make([]int,0)
//
//	for i:=0;i<len(nums1);i++{
//		index1[nums1[i]]++
//	}
//
//	for i:=0;i<len(nums2);i++{
//		v,ok := index1[nums2[i]]
//		if ok && v > 0{
//			result = append(result,v)
//			index1[nums2[i]]--
//		}
//	}
//	return result
//}
//func intersection(nums1 []int, nums2 []int) []int {
//	indexs := make(map[int]bool)
//	result := make([]int,0)
//	for i:= 0;i<len(nums1);i++{
//		if _, ok := indexs[nums1[i]];ok{
//			continue
//		}
//		indexs[nums1[i]]= false
//	}
//	for i:= 0;i<len(nums2);i++{
//		if v,ok := indexs[nums2[i]];ok && !v{
//			result = append(result,nums2[i])
//			indexs[nums2[i]] = true
//		}
//	}
//	return result
//}
//func reverseVowels(s string) string {
//	front,end := 0,len(s)
//	k := make(map[byte]bool)
//	k['a'] = true
//	k['e']= true
//	k['i']= true
//	k['o']= true
//	k['u']= true
//	for front < end{
//		for{
//			if _,ok := k[s[front]];!ok{
//				front++
//				continue
//			}
//			break
//		}
//		for{
//			if _,ok := k[s[end]];!ok{
//				front--
//				continue
//			}
//			break
//		}
//		s[]
//	}
//}

//type NumArray struct {
//	nums []int
//}
//
//
//func Constructor(nums []int) NumArray {
//	n := NumArray{
//		nums : make([]int,0),
//	}
//	return n
//}
//
//
//func (this *NumArray) SumRange(left int, right int) int {
//	res := 0
//	for i:= left;i<=right;i++{
//		res += this.nums[i]
//	}
//	return res
//}

//func wordPattern(pattern string, s string) bool {
//	word2ch := map[string]byte{}
//	ch2word := map[byte]string{}
//	words := strings.Split(s, " ")
//
//	if len(pattern) != len(words){
//		return false
//	}
//	for i,word := range words{
//		ch := pattern[i]
//		if word2ch[word] >0&& word2ch[word] != ch || ch2word[ch] != "" && ch2word[ch] != word{
//			return false
//		}
//		word2ch[word] = ch
//		ch2word[ch] = word
//	}
//	return true
//}

//func missingNumber(nums []int) int {
//	sort.Ints(nums)
//	for i:=0;i<len(nums);i++{
//		if i != nums[i]{
//			return i
//		}
//	}
//	return -1
//}

//func isUgly(n int) bool {
//	for n != 1{
//		if n % 2 == 0{
//			n= n/2
//		}else if n % 3 == 0{
//			n = n / 3
//		}else if n % 5 == 0{
//			n = n / 5
//		}else{
//			return false
//		}
//	}
//	return true
//}

//func binaryTreePaths(root *TreeNode) []string {
//	ress := make([]string,0)
//	if root == nil{
//		return nil
//	}
//	var reserse func(root *TreeNode,res string)
//	reserse = func(root *TreeNode,res string){
//		if root == nil{
//			ress = append(ress,res)
//			return
//		}
//		res = res+strconv.FormatInt(int64(root.Val),10)
//		if root.Left == nil && root.Right == nil{
//			ress = append(ress,res)
//		}else if root.Left != nil && root.Right != nil{
//			reserse(root.Left,res)
//			reserse(root.Right,res)
//		}else if root.Left !=nil{
//			reserse(root.Left,res)
//		}else {
//			reserse(root.Right,res)
//		}
//		return
//	}
//	res :=""
//	reserse(root,res)
//	return ress
//}

//func letcode(s string) int{
//	result := 0
//	k := "easy"
//	K := "EASY"
//	var reservelet func(index int,count int,res string)
//	reservelet = func(index int,count int,res string) {
//		if len(res) == 3 && index < len(s) && s[index] == 'y' || s[index] == 'Y'{
//			result++
//			return
//		}
//		for i:= index;i<len(s);i++{
//			if s[i] == k[count] || s[i] == K[count]{
//				res = res+string(s[i])
//				count +=1
//				reservelet(i+1,count,res)
//				res = res[:len(res)-1]
//				count--
//			}
//		}
//	}
//	for i:=0;i<len(s);i++{
//		if s[i] == k[0] || s[i] == K[0]{
//			reservelet(1,1,"e")
//		}
//	}
//	return result
//}
//
//
//
//func abc(s string) int{
//	res := 0
//	count := 0
//	key := "easy"
//	KEY := "EASY"
//	for i:=0;i<len(s);i++{
//		if s[i] == key[count] || s[i] == KEY[count]{
//			count++
//		}
//		if count == 4{
//			res++
//			count = 0
//		}
//	}
//	return res
//}

//
//func myAtoi(s string) int {
//	index := 0
//	positive := '+'
//	flag := false
//	ss := 0
//	for i:=0;i<len(s);i++{
//		if s[i] == ' '{
//			index++
//			continue
//		}
//		if index < len(s) {
//			if  s[index] == '-'{
//				positive = '-'
//				index++
//			}else if s[index] == '+'{
//				index++
//			}
//			break
//		}else{
//			return 0
//		}
//	}
//
//	res :=""
//	for i:=index;i<len(s);i++{
//		if s[i] - '0' >= 0 && s[i] - '0' <= 9{
//			if s[i] - '0' != 0 && flag == false{
//				ss = i
//			}
//			res += string(s[i])
//		}else{
//			break
//		}
//	}
//	//fmt.Println(res,res[0]-'0')
//	//fmt.Println(res)
//	t := 1
//	result := 0
//
//	for i:= len(res)-1;i>=0;i--{
//		result += int(res[i]-'0') * t
//		//fmt.Println(result,i,res[i]-'0',int(res[i]-'0') * t,t)
//		if t > int(math.Pow(2,31)) || i >= ss{
//			if result < int(math.Pow(2,31)){
//				break
//			}
//			result =  int(math.Pow(2,31))
//			break
//		}
//		if result > int(math.Pow(2,31)) {
//			fmt.Println(result)
//			result =  int(math.Pow(2,31))
//			break
//		}
//
//		t *= 10
//	}
//	//fmt.Println(result)
//	if positive == '+' && result == int(math.Pow(2,31)){
//		return result -1
//	}else if positive == '-'{
//		return result * -1
//	}
//
//	return result
//}

//
//func canWinNim(n int) bool {
//	f := make([]bool,n+1)
//	f[0] = true
//	f[1] = true
//	f[2] = true
//	for i := 3;i<n;i++{
//		f[i] = f[i-1] || f[i-2] || f[i-3]
//	}
//	return f[n]
//}
//
//
//func reverseWords(s string) string {
//	length := len(s)
//	ret := []byte{}
//
//	for i := 0;i<length;{
//		start := i
//		for i < length && s[i] != ' '{
//			i++
//		}
//		for p := start;p < i;p++{
//			ret = append(ret,s[start+i-1-p])
//		}
//		for i < length && s[i] == ' '{
//			i++
//			ret = append(ret,' ')
//		}
//	}
//	return string(ret)
//}

//func reconstructQueue(people [][]int) [][]int {
//	sort.Slice(people ,func(i,j int) bool {
//		a,b := people[i],people[j]
//		return a[0] > b[0] || a[0] == b[0] && a[1] < b[1]
//	})
//	res := make([][]int,0)
//	for i := 0;i < len(people);i++{
//		if people[i][1] >= len(res){
//			res = append(res,people[i])
//		}else{
//			res = append(res[:people[i][1]],append([][]int{people[i]},res[people[i][1]:]...)...)
//		}
//	}
//	return res
//}
//func reconstructQueue(people [][]int) [][]int {
//	sort.Slice(people, func(i, j int) bool {
//		a, b := people[i], people[j]
//		return a[0] < b[0] || a[0] == b[0] && a[1] > b[1]
//	})
//	ans := make([][]int, len(people))
//	for _, person := range people {
//		spaces := person[1] + 1
//		for i := range ans {
//			if ans[i] == nil {
//				spaces--
//				if spaces == 0 {
//					ans[i] = person
//					break
//				}
//			}
//		}
//	}
//	return ans
//}

//func canPartition(nums []int) bool {
//	if len(nums) < 0{
//		return false
//	}
//	sum,max1 := 0,0
//	for _,v := range nums{
//		sum += v
//		if v > max1 {
//			max1 = v
//		}
//	}
//	if sum % 2 == 1{
//		return false
//	}
//	if max1 > sum /2 {
//		return false
//	}
//	d := make([]bool,sum/2+1)
//	d[0] = true
//	for i := 0;i < len(nums);i++{
//		for j:=nums[i];j<=sum/2;j++{
//
//				d[j] = d[j] || d[j-nums[i]]
//
//		}
//	}
//	return d[sum/2]
//}
//func pathFrom(root *TreeNode,sum int) int{
//	if root == nil{
//		return 0
//	}
//	cnt := 0
//	if root.Val == sum{
//		cnt++
//	}
//	cnt += pathFrom(root.Left,sum-root.Val)
//	cnt += pathFrom(root.Right,sum -root.Val)
//	return cnt
//}
//func pathSum(root *TreeNode, sum int) int {
//	if root == nil { // 如果树为空
//		return 0 // 就返回0条路径
//	}
//	// 否则就返回所有满足条件的路径数量，一共包含三个部分
//	// 1. 起点为当前根节点的所有路径中满足条件的路径数量
//	// 2和3. 分别是递归求左右子树中满足条件的路径数量
//	return pathFrom(root, sum) + pathSum(root.Left, sum) + pathSum(root.Right, sum)
//}

//
//func findDisappearedNumbers(nums []int) []int {
//	mNum := make(map[int]bool)
//	for i:= 0;i<len(nums);i++{
//		mNum[nums[i]] = true
//	}
//	res := make([]int,0)
//	for i:=1;i<=n;i++{
//		if _,ok := mNum[i];!ok{
//			res = append(res,i)
//		}
//	}
//	return res
//}

//func hammingDistance(x int, y int) int {
//
//}
//
//func hammingDistance(x int, y int) int {
//	sum := x ^ y
//	result := 0
//	for sum != 0{
//		if sum & 1 == 1{
//			result++
//		}
//		sum = sum >> 1
//	}
//	return result
//}

//func findTargetSumWays(nums []int, target int) int {
//	sum := 0
//	for _, v := range nums{
//		sum += v
//	}
//	dim := sum - target
//	if dim < 0 || dim % 2 == 1{
//		return 0
//	}
//
//	d := make([][]int,len(nums)+1)
//
//	for i:=0;i<len(nums);i++{
//		d[i] = make([]int,dim/2+1)
//	}
//	d[0][0] = 1
//
//	for i:= 0;i<len(nums);i++{
//		for j:=0;j<=dim/2;j++{
//			d[i+1][j] = d[i][j]
//			if nums[i] <= j{
//				d[i+1][j] += d[i][j-nums[i]]
//			}
//		}
//	}
//	return d[len(nums)][dim/2]
//}
//func findTargetSumWays(nums []int, target int) int {
//	sum := 0
//	for _, v := range nums {
//		sum += v
//	}
//	diff := sum - target
//	if diff < 0 || diff%2 == 1 {
//		return 0
//	}
//	n, neg := len(nums), diff/2
//	dp := make([][]int, n+1)
//	for i := range dp {
//		dp[i] = make([]int, neg+1)
//	}
//	dp[0][0] = 1
//	for i, num := range nums {
//		for j := 0; j <= neg; j++ {
//			dp[i+1][j] = dp[i][j]
//			if j >= num {
//				dp[i+1][j] += dp[i][j-num]
//			}
//		}
//	}
//	return dp[n][neg]
//}

//
//func convertBST(root *TreeNode) *TreeNode {
//
// 	var reverseBST func (root *TreeNode,sum int) (int,bool)
// 	reverseBST = func(root *TreeNode,sum int) (int,bool){
// 		if root == nil{
// 			return 0 ,true
//		}
//		right,rok := reverseBST(root.Right,sum)
//		if rok {
//			root.Val = root.Val + right + sum
//		}else{
//			root.Val = root.Val + right
//		}
//		left,_ := reverseBST(root.Left,root.Val )
//		if root.Left != nil{
//			return left,false
//		}else{
//			return root.Val,false
//		}
//	}
//	reverseBST(root,0)
// 	return root
//}

//
// type TreeNode struct {
//	     Val int
//	     Left *TreeNode
//	     Right *TreeNode
//	 }
//
//func diameterOfBinaryTree(root *TreeNode) int {
//	result := 0
//	var reverseDiame func(root *TreeNode) int
//	reverseDiame = func(root *TreeNode) int{
//		if root == nil{
//			return 0
//		}
//		left := reverseDiame(root.Left)
//		right := reverseDiame(root.Right)
//		result = max(result,right+left+1)
//		if left > right{
//			return left+1
//		}
//		return right+1
//	}
//	reverseDiame(root)
//	return result
//}

//func subarraySum(nums []int, k int) int {
//	count, pre := 0, 0
//	m := map[int]int{}
//	m[0] = 1
//	for i := 0; i < len(nums); i++ {
//		pre += nums[i]
//		if _, ok := m[pre - k]; ok {
//			count += m[pre - k]
//		}
//		m[pre] += 1
//	}
//	return count
//}

//func subarraySum(nums []int, k int) int {
//	result := 0
//	SumF := make([]int,len(nums))
//	sum := 0
//	for i:=1;i<len(nums);i++{
//		 sum += nums[i]
//	}
//	SumF[0] = sum
//	if sum == k{
//		result++
//	}
//	for i:=1;i<len(nums);i++{
//		SumF[i] = SumF[i-1]-nums[i-1]
//		if SumF[i] == k{
//			result++
//		}
//	}
//}

//func findUnsortedSubarray(nums []int) int {
//	n := len(nums)
//	minn, maxn := math.MaxInt64, math.MinInt64
//	left, right := -1, -1
//	for i, num := range nums {
//		if maxn > num {
//			right = i
//		} else {
//			maxn = num
//		}
//		if minn < nums[n-i-1] {
//			left = n - i - 1
//		} else {
//			minn = nums[n-i-1]
//		}
//	}
//	if right == -1 {
//		return 0
//	}
//	return right - left + 1
//}

//
//func countSubstrings(s string) int {
//	var reverseSub func(index int,res string)
//	result := 0
//	if len(s) == 0{
//		return 0
//	}
//	reverseSub = func(index int,res string){
//		if IsSubstring(res){
//			fmt.Println(res)
//			result++
//		}
//		if len(res) == len(s)||index == len(s){
//			return
//		}
//
//		reverseSub(index+1,res+string(s[index]))
//		reverseSub(index+1,string(s[index]))
//
//	}
////	for i := 0;i<len(s);i++{
//		reverseSub(0,"")
////	}
//	return result
//}
//
//
//func IsSubstring(s string) bool{
//	if len(s) == 0{
//		return false
//	}
//	for i:=0;i<len(s)/2;i++{
//		if s[i] == s[len(s)-1-i]{
//			continue
//		}else{
//			return false
//		}
//	}
//	return true
//}
//func dailyTemperatures(temperatures []int) []int {
//	f := make([]int,0)
//	res := make([]int,len(temperatures))
//	for i:= 0; i<len(temperatures);i++{
//		if len(f) != 0{
//			for len(f)-1 >= 0 && temperatures[f[len(f)-1]] < temperatures[i]{
//				res[f[len(f)-1]] = i - f[len(f)-1]
//				f = f[:len(f)-1]
//			}
//		}
//		f = append(f,i)
//
//	}
//	return res
//}

//func topKFrequent(nums []int, k int) []int {
//	cnts := make(map[int]int,0)
//	res := make([][]int,k)
//	result := make([]int,k)
//	for i:=0;i<k;i++{
//		res[i] = make([]int,2)
//	}
//	for i:=0;i<len(nums);i++{
//		cnts[nums[i]]++
//	}
//
//	for i,v := range cnts{
//		if v > res[0][0]{
//			fmt.Println("front",res)
//			res = res[1:]
//			fmt.Println("middle",res)
//			k := false
//			for j:=len(res)-1;j>=0;j--{
//				if v > res[j][0]{
//					k = true
//					res = append(res[:j+1],append([][]int{{v,i}},res[j+1:]...)...)
//					break
//				}
//			}
//			if !k{
//				res = append([][]int{{v,i}},res[:]...)
//			}
//			fmt.Println("end",res)
//		}
//	}
//	for i:=0;i<k;i++{
//		result[i] = res[i][1]
//	}
//	return result
//}

//type ReusableObj struct{
//}
//
//type ObjPool struct {
//	bufChan chan *ReusableObj
//}
//
//func NewObjPool(numOfObj int) *ObjPool{
//	objPool := ObjPool{}
//	objPool.bufChan = make(chan *ReusableObj,numOfObj)
//	for i:=0;i<numOfObj;i++{
//		objPool.bufChan <- &ReusableObj{}
//	}
//	return &objPool
//}
//func (p *ObjPool) GetObj(timeout time.Duration) (*ReusableObj,error) {
//	select {
//	case ret := <- p.bufChan:
//		return ret,nil
//		case <-time.After(timeout):
//			return nil,errors.New("time out")
//	}
//}
//
//func (p *ObjPool) ReleaseObj(obj *ReusableObj) error{
//	select {
//	case p.bufChan <- obj:
//		return nil
//	default:
//		return errors.New("overflow")
//	}
//}

//func rob(root *TreeNode) int {
//	varl := reverRob(root)
//	return max(varl[0],varl[1])
//}
//func reverRob(root *TreeNode) []int{
//	if root == nil{
//		return []int{0,0}
//	}
//
//	l,r := reverRob(root.Left),reverRob(root.Right)
//	sele := root.Val + l[1] + r[1]
//	selenot := max(l[0],l[1]) + max(r[0],r[1])
//	return []int{sele,selenot}
//
//}

//func rob(root *TreeNode) int {
//	var reverRob func (root *TreeNode,res *int)
//	res1 := 0
//	res2 := 0
//
//	reverRob = func(root *TreeNode,res *int){
//		if root == nil{
//			return
//		}
//
//		*res += root.Val
//		if root.Left != nil {
//			if root.Left.Left != nil{
//				reverRob(root.Left.Left,res)
//			}
//			if root.Left.Right != nil{
//				reverRob(root.Left.Right,res)
//			}
//		}
//		if root.Right != nil {
//
//			if root.Right.Right != nil {
//				reverRob(root.Right.Right, res)
//			}
//			if root.Right.Left != nil{
//				reverRob((root.Right.Left,res))
//			}
//		}
//	}
//	reverRob(root,&res1)
//	reverRob(root.Left,&res2)
//	reverRob(root.Right,&res2)
//	return max(res1,res2)
//}

//func maxProfix(prices []int) int{
//	if len(prices) == 0{
//		return 0
//	}
//	n := len(prices)
//	f0,f1,f2 := -prices[0],0,0
//	for i:=1;i<n;i++{
//		newf0 := max(f0,f2-prices[i])
//		newf1 := f0+prices[i]
//		newf2 := max(f1,f2)
//		f0,f1,f2 = newf0,newf1,newf2
//	}
//	return max(f1,f2)
//}

//func findDuplicate(nums []int) int {
//	slow, fast := 0, 0
//	for slow, fast = nums[slow], nums[nums[fast]]; slow != fast; slow, fast = nums[slow], nums[nums[fast]] { }
//	slow = 0
//	for slow != fast {
//		slow = nums[slow]
//		fast = nums[fast]
//	}
//	return slow
//}

//func moveZeroes(nums []int)  {
//	if len(nums) == 0{
//		return
//	}
//	zeroIndex := 0
//	for zeroIndex < len(nums){
//		if nums[zeroIndex] == 0{
//			l := zeroIndex+1
//			for nums[l] == 0{
//				l++
//			}
//			if l == len(nums){
//				break
//			}
//			nums[zeroIndex],nums[l] = nums[l],nums[zeroIndex]
//		}
//		zeroIndex++
//	}
//}

//func numSquares(n int) int {
//	numSq := computeSquare(n)
//	f := make([]int,n+1)
//	f[0] = 0
//
//	for i:=1;i<=n;i++{
//		f[i] = f[i-1] + 1
//		for j:=0;j<len(numSq);j++{
//			if i-numSq[j] >= 0{
//				f[i] = min(f[i],f[i-numSq[j]]+1)
//			}else{
//				break
//			}
//		}
//	}
//	return f[n]
//}
//
//func computeSquare(n int) []int{
//	res := make([]int,0)
//
//	for i:=0;;i++{
//		if i*i < n{
//			res = append(res,i*i)
//		}else{
//			break
//		}
//	}
//	return res
//}

//func searchMatrix(matrix [][]int, target int) bool {
//	for i:=0;i<len(matrix);i++{
//		for j:=len(matrix[0])-1;j>=0;j--{
//			if matrix[i][j] ==  target{
//				return true
//			}else if matrix[i][j] < target{
//				break
//			}
//		}
//	}
//	return false
//}
//func searchMatrix(matrix [][]int, target int) bool {
//	for i:= len(matrix[0])-1;i>=0;i--{
//		if matrix[0][i] == target{
//			return true
//		}else if matrix[0][i] > target{
//			continue
//		}
//		for j:=1;j<len(matrix);j++{
//			if matrix[j][i] == target{
//				return true
//			}
//		}
//		return false
//	}
//	return false
//}

//func productExceptSelf(nums []int) []int {
//	if len(nums) == 0{
//		return nil
//	}
//	res := make([]int,len(nums))
//	left := make([]int,len(nums)+1)
//	right := make([]int,len(nums)+1)
//	left[0],right[0] = 1,1
//
//	for i:=1;i<=len(nums);i++{
//		left[i] = left[i-1] * nums[i-1]
//		right[i] = right[i-1] * nums[len(nums)-i]
//	}
//	fmt.Println(left,right)
//	for i:=0;i<len(nums);i++{
//		res[i] = left[i] * right[len(right)-2-i]
//	}
//	return res
//}

//func maximalSquare(matrix [][]string) int {
//	maxSquare := 0
//	//indexs := [][]int{{-1,0},{0,-1},{-1,-1}}
//	f := make([][]int,len(matrix)+1)
//	for i:=0;i<len(f);i++{
//		f[i] = make([]int,len(matrix[0])+1)
//	}
//
//	for i:=1;i<len(f);i++{
//		for j:=1;j<len(f[0]);j++{
//			if matrix[i-1][j-1] == "0"{
//				f[i][j] = 0
//				continue
//			}else if f[i-1][j-1] == f[i-1][j] && f[i-1][j] == f[i][j-1] && f[i-1][j-1] > 0{
//				f[i][j] = 1 + f[i-1][j-1]
//			}else if f[i-1][j-1] > 0 && f[i][j-1] > 0 && f[i-1][j] > 0{
//				minValue := min(f[i-1][j-1],min(f[i-1][j],f[i][j-1]))
//				f[i][j] = 1 + minValue
//			}else{
//				f[i][j] = 1
//			}
//			maxSquare = max(maxSquare,f[i][j]*f[i][j])
//		}
//	}
//	return maxSquare
//}

//func findKthLargest(nums []int, k int) int {
//	nums1 := QuickSortFindK(nums)
//	fmt.Println(nums1)
//	i := len(nums)-k
//	fmt.Println(nums,"i:",i)
//	return nums1[i]
//}
//
//func QuickSortFindK(nums []int) []int{
//	quickSortFindk(nums,0,len(nums)-1)
//	return nums
//}
//
//func quickSortFindk(nums []int,start,end int){
//	if start < end{
//		pivot := partitionFindk(nums,start,end)
//		quickSortFindk(nums,0,pivot-1)
//		quickSortFindk(nums,pivot+1,end)
//	}
//}
//
//func partitionFindk(nums []int,start,end int) int{
//	p := nums[end]
//	i := start
//	for j := start;j < end;j++{
//		if nums[j] < p{
//			swap(nums,i,j)
//			i++
//		}
//	}
//	swapFindK(nums,i,end)
//	return i
//}
//func swapFindK(nums []int,i,j int){
//	nums[i],nums[j] = nums[j],nums[i]
//}

//type Trie struct {
//	isEnd bool
//	wordtrie [26]*Trie
//}
//
//
///** Initialize your data structure here. */
//func Constructor() Trie {
//	return Trie{}
//}
//
//
///** Inserts a word into the trie. */
//func (this *Trie) Insert(word string)  {
//	k := this
//	for _,v := range word{
//		if k.wordtrie[v-'a'] == nil{
//			trie := Constructor()
//			k.wordtrie[v-'a'] = &trie
//		}
//		k = k.wordtrie[v-'a']
//	}
//	k.isEnd = true
//}
//
//
///** Returns if the word is in the trie. */
//func (this *Trie) Search(word string) bool {
//	k := this
//	for _,v := range word{
//		if k.wordtrie[v-'a'] == nil{
//			return false
//		}
//		k = k.wordtrie[v-'a']
//	}
//	return k.isEnd
//}
//
//
///** Returns if there is any word in the trie that starts with the given prefix. */
//func (this *Trie) StartsWith(prefix string) bool {
//	k := this
//	for _,v := range prefix{
//		if k.wordtrie[v-'a'] == nil{
//			return false
//		}
//		k = k.wordtrie[v-'a']
////	}
//	return true
//}

//func canFinish(numCourses int, prerequisites [][]int) bool {
//	var (
//		edges = make([][]int, numCourses)
//		visited = make([]int, numCourses)
//		result []int
//		valid = true
//		dfs func(u int)
//	)
//
//	dfs = func(u int) {
//		visited[u] = 1
//		for _, v := range edges[u] {
//			if visited[v] == 0 {
//				dfs(v)
//				if !valid {
//					return
//				}
//			} else if visited[v] == 1 {
//				valid = false
//				return
//			}
//		}
//		visited[u] = 2
//		result = append(result, u)
//	}
//
//	for _, info := range prerequisites {
//		edges[info[1]] = append(edges[info[1]], info[0])
//	}
//
//	for i := 0; i < numCourses && valid; i++ {
//		if visited[i] == 0 {
//			dfs(i)
//		}
//	}
//	return valid
//}

//
//func rob(nums []int) int {
//
//	f := make([]int,len(nums))
//	f[0] = nums[0]
//
//	for i:=1;i<len(nums);i++{
//		num := nums[i]
//		j:=i-3
//		if i-2>=0{
//			num = max(num,nums[i]+f[i-2])
//		}
//		if i-3>=0{
//			num = max(num,nums[i]+f[i-3])
//		}
//		f[i] = max(num,f[i-1])
//	}
//	//fmt.Println(f)
//	return f[len(nums)-1]
//}

//func maxProduct(nums []int) int {
//	maxF,minF,ans := nums[0],nums[0],nums[0]
//
//	for i:=1;i<len(nums);i++{
//		mx,mn := maxF,minF
//		maxF = max(mx*nums[i],max(nums[i],mn*nums[i]))
//		minF = min(mx*nums[i],min(nums[i],mn*nums[i]))
//		ans = max(ans,maxF)
//	}
//	return ans
//}
//type LRUCache struct {
//	size int
//	capacity int
//	cache map[int]*DLinkedNode
//	head, tail *DLinkedNode
//}
//
//type DLinkedNode struct {
//	key, value int
//	prev, next *DLinkedNode
//}
//
//func initDLinkedNode(key, value int) *DLinkedNode {
//	return &DLinkedNode{
//		key: key,
//		value: value,
//	}
//}
//
//func Constructor(capacity int) LRUCache {
//	l := LRUCache{
//		cache: map[int]*DLinkedNode{},
//		head: initDLinkedNode(0, 0),
//		tail: initDLinkedNode(0, 0),
//		capacity: capacity,
//	}
//	l.head.next = l.tail
//	l.tail.prev = l.head
//	return l
//}
//
//func (this *LRUCache) Get(key int) int {
//	if _, ok := this.cache[key]; !ok {
//		return -1
//	}
//	node := this.cache[key]
//	this.moveToHead(node)
//	return node.value
//}
//
//
//func (this *LRUCache) Put(key int, value int)  {
//	if _, ok := this.cache[key]; !ok {
//		node := initDLinkedNode(key, value)
//		this.cache[key] = node
//		this.addToHead(node)
//		this.size++
//		if this.size > this.capacity {
//			removed := this.removeTail()
//			delete(this.cache, removed.key)
//			this.size--
//		}
//	} else {
//		node := this.cache[key]
//		node.value = value
//		this.moveToHead(node)
//	}
//}
//
//func (this *LRUCache) addToHead(node *DLinkedNode) {
//	node.prev = this.head
//	node.next = this.head.next
//	this.head.next.prev = node
//	this.head.next = node
//}
//
//func (this *LRUCache) removeNode(node *DLinkedNode) {
//	node.prev.next = node.next
//	node.next.prev = node.prev
//}
//
//func (this *LRUCache) moveToHead(node *DLinkedNode) {
//	this.removeNode(node)
//	this.addToHead(node)
//}
//
//func (this *LRUCache) removeTail() *DLinkedNode {
//	node := this.tail.prev
//	this.removeNode(node)
//	return node
//}

//type LRUCache struct {
//	list []int
//	listMap map[int]ValueIndex
//	maxlen int
//}
//type ValueIndex struct{
//	value int
//	index int
//}
//
//func Constructor(capacity int) LRUCache {
//	new1 := LRUCache{
//		list: make([]int,0),
//		listMap: make(map[int]ValueIndex),
//		maxlen: capacity,
//	}
//	return new1
//}
//
//
//func (this *LRUCache) Get(key int) int {
//	if v,ok := this.listMap[key];ok{
//		this.list = append(this.list[:v.index],append(this.list[v.index+1:],key)...)
//		this.listMap[key]  = ValueIndex{
//			value: v.value,
//			index: len(this.list)-1,
//		}
//		return v.value
//	}
//	return -1
//}
//
//
//func (this *LRUCache) Put(key int, value int)  {
//	if v,ok := this.listMap[key];ok{
//		this.list = append(this.list[:v.index],append(this.list[v.index+1:],key)...)
//		this.listMap[key]  = ValueIndex{
//			value: value,
//			index: len(this.list)-1,
//		}
//	}else{
//		if len(this.list) == this.maxlen{
//			delete(this.listMap,this.list[0])
//			this.list = this.list[1:]
//		}
//		this.list = append(this.list, key)
//		this.listMap[key] = ValueIndex{
//			value: value,
//			index: len(this.list)-1,
//		}
//	}
//}
//func longestConsecutive(nums []int) int {
//	if len(nums) == 0{
//		return 0
//	}
//	numsMap := make(map[int]bool)
//	maxlen := 1
//	for _, num := range nums {
//		numsMap[num] = true
//	}
//
//	for k,_ := range numsMap{
//		if numsMap[k-1]{
//			continue
//		}
//		count := 1
//		k++
//		for numsMap[k]{
//			count++
//			k++
//		}
//		maxlen = max(maxlen,count)
//	}
//	return maxlen
//}

//func longestConsecutive(nums []int) int {
//	if len(nums) == 0{
//		return 0
//	}
//	res := 1
//	sort.Ints(nums)
//	fmt.Println((nums))
//	num := 1
//	for i:=0;i<len(nums)-1;i++{
//		if nums[i+1] == nums[i]{
//			continue
//		}
//		if nums[i+1] - nums[i] == 1{
//			num++
//			fmt.Println(num)
//			continue
//		}
//		res = max(res,num)
//		num=1
//	}
//	res = max(res,num)
//	return res
//}
//func flatten(root *TreeNode)  {
//	if root == nil{
//		return
//	}
//	nodes := reverFlattern(root)
//	root.Left = nil
//	root.Right = nodes.Right
//}
//func reverFlattern(root *TreeNode) *TreeNode{
//	node := &TreeNode{}
//	if root == nil{
//		return nil
//	}
//	node.Val = root.Val
//	node1 := reverFlattern(root.Left)
//	node2 := reverFlattern(root.Right)
//	if node1 == nil{
//		node.Right = node2
//	}else{
//		node.Right = node1
//		for node1.Right != nil{
//			node1 = node1.Right
//		}
//		node1.Right = node2
//	}
//
//	return  node
//}

//func numTrees(n int) int {
//	d := make([]int,n+1)
//	d[0] = 1
//	d[1] = 1
//	for i:=2;i<=n;i++{
//		for j:=0;j<i;j++{
//			d[i] += d[j] * d[i-j-1]
//		}
//	}
//	return d[n+1]
//}

//func numTrees(n int) int {
//	result := 0
//	indexs := make([]bool,n+1)
//	numTree := make([]int,0)
//	var ReversNumTree func()
//
//	ReversNumTree = func(){
//		if len(numTree) == n{
//			fmt.Println("res",numTree)
//			result++
//			return
//		}
//		fmt.Println(numTree)
//		for i:=1;i<=n;i++{
//			if indexs[i]{
//				continue
//			}
//			indexs[i] = true
//			numTree = append(numTree,i)
//			if !IsFrontTree(numTree){
//				numTree = numTree[:len(numTree)-1]
//				indexs[i] = false
//				continue
//			}
//			ReversNumTree()
//			numTree = numTree[:len(numTree)-1]
//			indexs[i] = false
//		}
//	}
//	for i:=1;i<=n;i++{
//		ReversNumTree()
//	}
//	return result
//}
//
//func IsFrontTree(nums []int) bool{
//	k := nums[len(nums)-1]
//	n := len(nums)-3
//	for n >= 0{
//		if nums[n+1] < nums[n]&& k < nums[n] || nums[n+1] > nums[n]&& k > nums[n] {
//			n-=2
//			continue
//		}else{
//			return false
//		}
//
//	}
//	return true
//}

//func exist(board [][]byte, word string) bool {
//	trix := [][]int{{-1,0},{1,0},{0,-1},{0,1}}
//	var reversExit func(i,j int,index int) bool
//	h, w := len(board), len(board[0])
//	indexs := make([][]bool,h)
//	for k:=0;k<len(indexs);k++{
//		indexs[k] = make([]bool,w)
//	}
//	reversExit = func(i,j int,index int)bool{
//		if target == word{
//			//fmt.Println("true",target)
//			return true
//		}else if board[i][j] != word[index]{
//			return false
//		}
//		defer func(){
//			indexs[i][j] = false
//		}()
//		//fmt.Println("normal",target,i,j,index)
//
//		indexs[i][j] = true
//		for _,v := range trix{
//			if newi,newj := i+v[0],j+v[1];newi>=0 && newi<h && newj>=0 && newj<w&&!indexs[newi][newj]{
//				if reversExit(newi,newj,index+1){
//					return true
//				}
//			}
//		}
//
//		return false
//	}
//
//
//	for i:=0;i<len(board);i++{
//		for j:=0;j<len(board[0]);j++{
//			if reversExit(i,j,0){
//				return true
//			}
//		}
//	}
//	return false
//}

//func merge(intervals [][]int) [][]int {
//	sort.Slice(intervals,func(i,j int)bool{
//		return intervals[i][0] < intervals[j][0]
//	})
//
//	res := [][]int{}
//	prev := intervals[0]
//
//	for i:=1;i<len(intervals);i++{
//		cur := intervals[i]
//		if prev[1] < cur[0]{
//			res = append(res,prev)
//			prev = cur
//		}else{
//			prev[1] = max(prev[1],cur[1])
//		}
//	}
//	res = append(res,prev)
//	return res
//}
//func merge(intervals [][]int) [][]int {
//
//	for i:=0;i<len(intervals)-1;i++{
//		k := false
//		for j:=i+1;j<=len(intervals)-1;j++{
//			if intervals[i][1] >= intervals[j][0] && intervals[i][0] <= intervals[j][1]{
//				//fmt.Println(i)
//				start := min(intervals[i][0],intervals[j][0])
//				end := max(intervals[i][1],intervals[j][1])
//				res := []int{start,end}
//				intervals = append(intervals[:j],intervals[j+1:]...)
//				intervals = append(intervals[:i],append([][]int{res},intervals[i+1:]...)...)
//				j--
//				k = true
//			}
//		}
//		if k{
//			i--
//		}
//
//	}
//	return intervals
//}

//func groupAnagrams(strs []string) [][]string {
//	if len(strs) == 0{
//		return nil
//	}
//	result := make([][]string,0)
//	strMap := make(map[[26]int][]string)
//
//	for _,v := range strs{
//		cnt := [26]int{}
//		for _,k := range v{
//			cnt[k-'a']++
//		}
//		strMap[cnt] = append(strMap[cnt],v)
//	}
//	for _,v := range strMap{
//		result = append(result,v)
//	}
//	return result
//}

//func groupAnagrams(strs []string) [][]string {
//	if len(strs) == 0{
//		return nil
//	}
//	result := make([][]string,0)
//
//	indexMap := make(map[int]bool)
//
//	for i:=0;i<len(strs);i++{
//		if _,ok := indexMap[i];ok{
//			continue
//		}
//		indexMap[i] = true
//		strMap := make(map[string]int)
//		res := make([]string,0)
//		res = append(res,strs[i])
//
//	}
//}
//
//func RerverGroup(str string,res []string){
//	if
//}

//func rotate(matrix [][]int)  {
//	if len(matrix) == 0 || len(matrix[0]) == 0 {
//		return
//	}
//	for i:=0;i<len(matrix);i++{
//		for j:=0;j<len(matrix[0])/2;j++{
//			matrix[i][j],matrix[i][len(matrix[0])-j-1] = matrix[i][len(matrix[0])-j-1],matrix[i][j]
//		}
//	}
//	for i:=0;i<len(matrix);i++{
//		for j:=0;j<len(matrix[0])-i;j++{
//			matrix[i][j],matrix[len(matrix)-j-1][len(matrix[0])-i-1] = matrix[len(matrix)-j-1][len(matrix[0])-i-1],matrix[i][j]
//		}
//	}
//	//fmt.Println(matrix)
//}
//func combinationSum(candidates []int, target int) [][]int {
//	if len(candidates) == 0{
//		return nil
//	}
//	result := make([][]int,0)
//	var reverCandidate func(candidates []int,index int,sum int,res []int)
//	reverCandidate = func(candidates []int,index int,sum int,res []int){
//		fmt.Println(res,sum,target)
//		if sum == target{
//			 k := make([]int,len(res))
//			 copy(k,res)
//			result = append(result,k)
//			//fmt.Println("result:",result,"res:",res)
//			return
//		}else if sum > target{
//			return
//		}
//		for i:=index;i<len(candidates);i++{
//			if sum + candidates[i] > target{
//				break
//			}
//			res = append(res,candidates[i])
//			reverCandidate(candidates,i,sum+candidates[i],res)
//			res = res[:len(res)-1]
//		}
//	}
//	res := make([]int,0)
//	sort.Ints(candidates)
//	reverCandidate(candidates,0,0,res)
//	return result
//}

//func combinationSum(candidates []int, target int) [][]int {
//	if len(candidates) == 0{
//		return nil
//	}
//	result := make([][]int,0)
//	candiMap := make(map[int]bool)
//
//	for i:=0;i<len(candidates);i++{
//		if _,ok := candiMap[candidates[i]];!ok{
//			candiMap[candidates[i]] = true
//		}
//	}
//
//	for i:=0;i<len(candidates);i++{
//		k := candidates[i] % target
//		if k  == 0{
//			lenCan := candidates[i]/target
//			res := make([]int,lenCan)
//			for lenCan != 0{
//				res[lenCan-1] = candidates[i]
//				lenCan--
//			}
//			result = append(result,res)
//		}else if _,ok := candiMap[k];ok{
//			lenCan := candidates[i]/target
//			res := make([]int,lenCan+1)
//			for lenCan != 0{
//				res[lenCan-1] = candidates[i]
//				lenCan--
//			}
//			res[0] = k
//			result = append(result,res)
//		}
//	}
//}

//func searchRange(nums []int, target int) []int {
//	if len(nums) == 0{
//		return []int{-1,-1}
//	}
//	left,right := 0,len(nums)-1
//	result := []int{-1,-1}
//
//	for left+1<right{
//		mid := left + (right-left)/2
//		if nums[mid] == target{
//			left = mid
//			break
//		}else if nums[mid] > target{
//			right = mid
//		}else{
//			left = mid
//		}
//	}
//	if nums[left] == target || nums[right] == target {
//		temp, val := 0, 0
//		if nums[left] == target {
//			temp, val = left, left
//		} else {
//			temp, val = right, right
//		}
//
//		for temp+1 < len(nums) && nums[temp+1] == target {
//			temp++
//		}
//		result[1] = temp
//
//		temp = val
//		for temp-1 >= 0 && nums[temp-1] == target {
//			temp--
//		}
//		result[0] = temp
//	}
//	return result
//}

//func nextPermutation(nums []int)  {
//	if len(nums) == 1{
//		return
//	}
//	h:= len(nums) -1
//	for i:=h-1;i>=0;i--{
//		if nums[i] < nums[i+1]{
//			for j:= h;j>=i+1;j--{
//				if nums[j] > nums[i]{
//					nums[i],nums[j] = nums[j],nums[i]
//
//					for k:=i+1;k<i+1+len(nums[i+1:])/2;k++{
//						nums[k],nums[len(nums)-k+i] = nums[len(nums)-k+i],nums[k]
//					}
//					return
//				}
//			}
//		}
//	}
//	for i:=0;i<len(nums)/2;i++{
//
//		nums[i],nums[h-i] = nums[h-i],nums[i]
//
//	}
//
//}
//func nextPermutation(nums []int) {
//	if len(nums) == 1{
//		return
//	}
//	h := len(nums) - 1
//	for i:= h;i>0;i--{
//		if nums[i] > nums[i-1]{
//			nums[i],nums[i-1] = nums[i-1],nums[i]
//			sort.Ints(nums[i:])
//			return
//		}
//	}
//}
//func nextPermutation(nums []int)  {
//	if len(nums) == 1{
//		return
//	}
//	h := len(nums)-1
//	for i:= h;i>0;i--{
//		for j:=i-1;j>=0;j--{
//			if nums[i] > nums[j]{
//				num := nums[i]
//				nums = append(nums[:i],nums[i+1:]...)
//				nums = append(nums[:j],append([]int{num},nums[j:]...)...)
//				for k:=h;k>i;k--{
//					if nums[k] < nums[i]{
//						nums[k],nums[i] = nums[i],nums[k]
//						return
//					}
//				}
//				return
//			}
//		}
//	}
//	for i:=0;i<len(nums)/2;i++{
//
//		nums[i],nums[h-i] = nums[h-i],nums[i]
//
//	}
//	return
//}

//func generateParenthesis(n int) []string {
//	result := []string{}
//	left,right := n,n
//	var backParenth func(left,right int,res string)
//	backParenth = func(left,right int,res string){
//		if len(res) == 2*n{
//			result = append(result,res)
//		}
//		if left > 0{
//			backParenth(left-1,right,res+"(")
//		}
//		if right>left{
//			backParenth(left,right-1,res + ")")
//		}
//	}
//	backParenth(left,right,"")
//	return result
//}

//func backParenth(left,right int,res string,n int){
//	if len(res) == 2*n{
//		result = append(result,res)
//	}
//	if left > 0{
//		backParenth(left-1,right,res+"(",n)
//	}
//	if right>left{
//		backParenth(left,right-1,res + ")",n)
//	}
//}

//type ListNode struct {
//     Val int
//     Next *ListNode
// }

//func removeNthFromEnd(head *ListNode, n int) *ListNode {
//	if head == nil{
//		return nil
//	}
//
//	dump := &ListNode{}
//	dump.Next = head
//	left,right := dump,dump
//	for n > 0{
//		right = right.Next
//		n--
//	}
//	for right.Next != nil{
//		right = right.Next
//		left = left.Next
//	}
//	left.Next = left.Next.Next
//	return head
//}

//if sum == target {
//	result = append(result,[]int{nums[first] ,nums[second],nums[three] , nums[forth]})
//} else if sum < target {
//	k0 := three + 1
//	for k0 < forth && nums[k0] == nums[k0-1] {
//		k0++
//	}
//	three = k0
//} else {
//	k0 := forth - 1
//	for k0 > three && nums[k0] == nums[k0+1] {
//		k0--
//	}
//	forth = k0
//}
//
//
//func fourSum(nums []int, target int) [][]int {
//	if len(nums) < 4 {
//		return nil
//	}
//	result := make([][]int, 0)
//	n := len(nums)
//	for first := 0; first < n; first++ {
//		if first > 0 && nums[first] == nums[first-1] {
//			continue
//		}
//		for second := first + 1; second < n; second++ {
//			if second > first+1 && nums[second] == nums[second-1] {
//				continue
//			}
//			three := second + 1
//			forth := n - 1
//
//			for three < forth {
//				sum := nums[first] + nums[second]+nums[three]+nums[forth]
//				if sum == target {
//					result = append(result, []int{nums[first], nums[second], nums[three], nums[forth]})
//				} else if sum+nums[three]+nums[forth] < target {
//					three++
//				} else {
//					forth--
//				}
//			}
//		}
//	}
//	return result
//}
//func fourSum(nums []int, target int) [][]int {
//	n := len(nums) - 1
//	sort.Ints(nums)
//	result := make([][]int, 0)
//	//sresult := 0
//	for first := 0; first <= n; first++ {
//		if first > 0 && nums[first] == nums[first-1] {
//			continue
//		}
//		for second := first + 1; second < n; second++ {
//			if second > first+1 && nums[second] == nums[second-1] {
//				continue
//			}
//			left := second + 1
//			right := n
//
//			for left < right {
//				sum := nums[first] + nums[second]+nums[left] + nums[right]
//				if sum == target {
//					result = append(result,[]int{nums[first] ,nums[second],nums[left] , nums[right]})
//				}
//				if sum < target {
//					k0 := left + 1
//					for k0 < right && nums[k0] == nums[k0-1] {
//						k0++
//					}
//					left = k0
//				} else {
//					k0 := right - 1
//					for k0 > left && nums[k0] == nums[k0+1] {
//						k0--
//					}
//					right = k0
//				}
//			}
//		}
//	}
//	return result
//}

//var phoneMap map[string]string = map[string]string{
//	"2": "abc",
//	"3": "def",
//	"4": "ghi",
//	"5": "jkl",
//	"6": "mno",
//	"7": "pqrs",
//	"8": "tuv",
//	"9": "wxyz",
//}
//
//var combinations []string
//func letterCombinations(digits string) []string {
//	if len(digits) == 0{
//		return []string{}
//	}
//	combinations = []string{}
//	backtrack(digits,0,"")
//	return combinations
//}
//
//func backtrack(digits string,index int,combination string){
//	if index == len(digits){
//		combinations = append(combinations,combination)
//	}
//	dit := digits[index]
//	s := phoneMap[string(dit)]
//
//	for i:=0;i<len(s);i++{
//		backtrack(digits,index+1,combination + string(s[i]))
//	}
//}

//func letterCombinations(digits string) []string {
//	if len(digits) == 0{
//		return nil
//	}
//	result := make([]string,0)
//	indexstr := make(map[byte][]byte)
//	indexstr['2'] = []byte{'a','b','c'}
//
//}

//func threeSum(nums []int) [][]int {
//	n := len(nums)-1
//	sort.Ints(nums)
//	target := 0
//	result := make([][]int,0)
//	for first := 0;first <=n ;first++{
//		if first > 0 && nums[first] == nums[first-1]{
//			continue
//		}
//		left := first + 1
//		right := n
//
//		for left < right{
//			sum := nums[first] + nums[left] + nums[right]
//			if sum == target{
//				res := []int{ nums[first] ,nums[left] ,nums[right]}
//				result = append(result,res)
//			}
//			if sum < target{
//				k0 := left+1
//				for k0 < right && nums[k0] == nums[k0-1]{
//					k0++
//				}
//				left=k0
//			}else{
//				k0 := right-1
//				for k0 > left && nums[k0] == nums[k0+1]{
//					k0--
//				}
//				right=k0
//			}
//		}
//	}
//
//	return result
//}
//func threeSumClosest(nums []int,target int) int {
//	n := len(nums)-1
//	sort.Ints(nums)
//	minSum := 1<<32
//	//sresult := 0
//	for first := 0;first <=n ;first++{
//		if first > 0 && nums[first] == nums[first-1]{
//			continue
//		}
//		left := first + 1
//		right := n
//
//		for left < right{
//			sum := nums[first] + nums[left] + nums[right]
//			if sum == target{
//				return target
//			}
//			if abs(sum-target) < abs(minSum-target){
//				minSum=sum
//			}
//			if sum < target{
//				k0 := left+1
//				for k0 < right && nums[k0] == nums[k0-1]{
//					k0++
//				}
//				left=k0
//			}else{
//				k0 := right-1
//				for k0 > left && nums[k0] == nums[k0+1]{
//					k0--
//				}
//				right=k0
//			}
//		}
//	}
//
//	return minSum
//}
//func abs(x int) int {
//	if x < 0 {
//		return -1 * x
//	}
//	return x
//}
//func SeekZero(nums []int) int{
//	l := 0
//	r := len(nums)-1
//
//	for l+1 < r{
//		mid := l + (r-l)/2
//		if nums[mid] == 0{
//			return mid
//		}else if nums[mid] < 0{
//			l = mid
//		}else{
//			r = mid
//		}
//	}
//	if nums[r] == 0{
//		return r
//	}
//	if nums[l]==0{
//		return l
//	}
//	return 1<<31
//}
//func intToRoman(num int) string {
//	res := ""
//
//	for num != 0{
//		if k := num / 1000; k != 0{
//
//		}
//	}
//}

//func maxArea(height []int) int {
//	if len(height) == 0{
//		return 0
//	}
//	left := 0
//	right := len(height)-1
//	res := 0
//	for left + 1 <= right{
//		if height[left] < height[right]{
//			res = max(res,height[left] * (right - left))
//			left++
//		}else{
//			res = max(res,height[right] * (right - left))
//			right--
//		}
//	}
//	return res
//}

//func maxArea(height []int) int {
//	if len(height) == 0{
//		return 0
//	}
//	maxvalue := 0
//	list := make(map[int]int)
//	for i:=0;i<len(height);i++{
//		if _,ok := list[height[i]];ok{
//			continue
//		}else{
//			value := AreLR(height,i)
//			list[height[i]]=value
//			maxvalue = max(maxvalue,value)
//		}
//	}
//	return maxvalue
//}

//func AreLR(height []int,i int) int{
//	left,right := i-1,i+1
//	leftk := 0
//	rightk := 0
//	for left >= 0 || right <len(height) {
//		if  left >= 0 && height[left] >= height[i]{
//			leftk = i-left
//		}
//		left--
//		if  right < len(height) && height[right] >= height[i]{
//			rightk = right - i
//		}
//		right++
//	}
//
//	return height[i]*(rightk+leftk)
//}
//func longestPalindrome(s string) string {
//	if s == "" {
//		return ""
//	}
//	start, end := 0, 0
//	for i := 0; i < len(s); i++ {
//		left1, right1 := expandAroundCenter(s, i, i)
//		left2, right2 := expandAroundCenter(s, i, i + 1)
//		if right1 - left1 > end - start {
//			start, end = left1, right1
//		}
//		if right2 - left2 > end - start {
//			start, end = left2, right2
//		}
//	}
//	return s[start:end+1]
//}
//
//func expandAroundCenter(s string, left, right int) (int, int) {
//	for ; left >= 0 && right < len(s) && s[left] == s[right]; left, right = left-1 , right+1 { }
//	return left + 1, right - 1
//}
//
//
//func longestPalindrome(s string) string {
//	if len(s) == 0{
//		return ""
//	}
//	//f := make([]int,len(s)+1)
//	//f[0] = 1
//	max := string(s[0])
//	for i:=1;i<len(s);i++{
//		//f[i] = 1
//		for j:=0;j<i;j++{
//			//fmt.Println(s[j:i+1],j,i)
//			if len(max) >= i-j+1 {
//				break
//			} else if IsPalind(s[j:i+1]){
//					max = s[j:i+1]
//			}
//		}
//	}
//	return max
//}
//
//func IsPalind(s string) bool{
//	for i:=0;i<len(s);i++{
//		if s[i] != s[len(s)-i-1]{
//			return false
//		}
//	}
//	return true
//}
//

//func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
//	res := &ListNode{}
//	list := res
//	front := 0
//
//	for l1 != nil && l2 != nil {
//		temp := &ListNode{}
//		if l1.Val+l2.Val+front > 9 {
//			temp.Val = (l1.Val + l2.Val + front) % 10
//			front = 1
//		} else {
//			temp.Val = l1.Val + l2.Val + front
//			front = 0
//		}
//		list.Next = temp
//		list = list.Next
//		l1 = l1.Next
//		l2 = l2.Next
//	}
//
//	if front == 1 && l1 == nil && l2 == nil {
//		temp := &ListNode{}
//		temp.Val = 1
//		list.Next = temp
//	} else if front == 0 && l1 != nil {
//		list.Next = l1
//	} else if front == 0 && l2 != nil {
//		list.Next = l2
//	} else if front == 1 && l1 != nil{
//		for front == 1 {
//			temp := &ListNode{}
//			if l1 != nil && l1.Val+1 > 9 {
//				temp.Val = 0
//				l1 = l1.Next
//				front = 1
//			} else if l1 != nil && l1.Val+1 <= 9 {
//				temp.Val = l1.Val + 1
//				front = 0
//				l1 = l1.Next
//				list.Next = temp
//				list = list.Next
//				list.Next = l1
//				break
//			} else {
//				temp.Val = 1
//				front = 0
//			}
//			list.Next = temp
//			list = list.Next
//		}
//	}else{
//		for front == 1 {
//			temp := &ListNode{}
//			if l2 != nil && l2.Val+1 > 9 {
//				temp.Val = 0
//				l2 = l2.Next
//				front = (l2.Val + 1) /10
//			} else if l2 != nil && l2.Val+1 <= 9 {
//				temp.Val = l2.Val + 1
//				front = 0
//				l2 = l2.Next
//				list.Next = temp
//				list = list.Next
//				list.Next = l2
//				break
//			} else {
//				temp.Val = 1
//				front = 0
//			}
//			list.Next = temp
//			list = list.Next
//		}
//	}
//
//	return res.Next
//}

//func SumList(node *ListNode) int{
//	res := 0
//	k := 1
//	for node != nil{
//		res = res + (node.Val * k)
//		k *= 10
//		node = node.Next
//	}
//	return res
//}

//func twoSum(nums []int, target int) []int {
//	if len(nums) < 0{
//		return nil
//	}
//	list := make(map[int]int)
//	res := make([]int,2)
//	for i:=0;i<len(nums);i++{
//		if j,ok:=list[target - nums[i]];ok{
//			res[0] = i
//			res[1] = j
//		}else{
//			list[nums[i]]=i
//		}
//	}
//	return res
//}

//func minNumber(nums []int) string {
//	if len(nums) == 0{
//		return ""
//	}
//	f := make([]string,len(nums))
//	f[0] = strconv.Itoa(nums[0])
//	for i:=1;i<len(nums);i++ {
//		num1, _ := strconv.ParseInt(f[i-1]+strconv.Itoa(nums[i]), 10, 64)
//		num2, _ := strconv.ParseInt(strconv.Itoa(nums[i])+f[i-1], 10, 64)
//		if num1 < num2 {
//			f[i] = f[i-1] + strconv.Itoa(nums[i])
//		} else {
//			f[i] = strconv.Itoa(nums[i]) + f[i-1]
//		}
//		fmt.Println(f[i],num1,num2)
//	}
//	return f[len(nums)-1]
//}

//func twoSum(nums []int,target int) []int{
//	if len(nums) == 0 {
//		return nil
//	}
//	result := make([]int,2)
//	start,end := 0,len(nums)-1
//	for start < end{
//		if nums[start] + nums[end] == target {
//			result[0] = nums[start]
//			result[1] = nums[end]
//			return result
//		}else if nums[start] + nums[end] < target{
//			start++
//		}else{
//			end--
//		}
//	}
//	return nil
//}
//func twoSum(nums []int, target int) []int {
//	if len(nums) == 0{
//		return nil
//	}
//	k := make(map[int]bool)
//	result := make([]int,0)
//	for i:=0;i<len(nums);i++{
//		if _,ok :=k[target - nums[i]];ok{
//			result = append(result,nums[i])
//			result = append(result,target-nums[i])
//			return result
//		}
//		k[nums[i]] = true
//	}
//	return nil
//}
//func singleNumber(nums []int) int {
//	result := 0
//
//	for i:=0;i<64;i++{
//		sum := 0
//		for j:=0;j<len(nums);j++{
//			sum += (nums[j] >> j) & 1
//		}
//		result ^= (sum % 3)
//	}
//	return result
//}
//func singleNumbers(nums []int) []int {
//	if len(nums) == 0{
//		return 0
//	}
//	res := 0
//	for i:=0;i<len(nums);i++{
//		res ^= nums[i]
//	}
//	bit := 0
//	for res & (1 << bit) != 1{
//		bit++
//	}
//	num1 := 0
//	for i:=0;i<len(nums);i++{
//		if nums[i] & (1<<bit) == 1{
//			num1 ^= nums[i]
//		}
//	}
//	num2 := num1 ^ res
//	result := []int{num1,num2}
//	return result
//}

// type TreeNode struct {
//	     Val int
//	     Left *TreeNode
//	     Right *TreeNode
//	 }
//
//func maxDepth(root *TreeNode) int {
//	if root == nil{
//		return 0
//	}
//	left := maxDepth(root.Left)
//	right := maxDepth(root.Right)
//
//	if left > right{
//		return left+1
//	}
//	return right+1
//}
//func reversePairs(nums []int) int {
//	return mergeSort(nums, 0, len(nums)-1)
//}
//
//func mergeSort(nums []int,start,end int) int{
//	if start >= end{
//		return 0
//	}
//	mid := start + (end - start)/2
//	cnt := mergeSort(nums,start,mid) + mergeSort(nums,mid+1,end)
//	tmp := make([]int,0)
//	i,j := start,end
//	for i <= mid && k <= end{
//		if nums[i] <= nums[j]{
//			tmp  = append(tmp,nums[i])
//			i++
//			cnt += j - (mid+1)
//		}else{
//			j++
//			tmp = append(tmp,nums[j])
//		}
//	}
//
//	for ;i<=mid;i++{
//		tmp = append(tmp,nums[i])
//		cnt += end - mid
//	}
//	for ;j<=end;j++{
//		tmp = append(tmp,nums[j])
//	}
//
//	for i:=start;i<=end;i++{
//		nums[i] = tmp[i-start]
//	}
//	return cnt
//}

//func reversePairs(nums []int) int {
//	return mergeSort(nums, 0, len(nums)-1)
//}
//
//func mergeSort(nums []int, start, end int) int {
//	if start >= end {
//		return 0
//	}
//	mid := start + (end - start)/2
//	cnt := mergeSort(nums, start, mid) + mergeSort(nums, mid + 1, end)
//	tmp := []int{}
//	i, j := start, mid + 1
//	for i <= mid && j <= end {
//		if nums[i] <= nums[j] {
//			tmp = append(tmp, nums[i])
//			cnt += j - (mid + 1)
//			i++
//		} else {
//			tmp = append(tmp, nums[j])
//			j++
//		}
//	}
//	for ; i <= mid; i++ {
//		tmp = append(tmp, nums[i])
//		cnt += end - (mid + 1) + 1
//	}
//	for ; j <= end; j++ {
//		tmp = append(tmp, nums[j])
//	}
//	for i := start; i <= end; i++ {
//		nums[i] = tmp[i - start]
//	}
//	return cnt
//}
//
//
//type TreeNode struct {
// 	Val int
// 	Left *TreeNode
// 	Right *TreeNode
//}
//
//func pathSum(root *TreeNode, target int) [][]int {
//	res := make([][]int,0)
//	path := make([]int,0)
//	pathSumRever(root,target,path,&res)
//	return res
//}
//
//func pathSumRever(root *TreeNode,target int,path []int,res *[][]int){
//	if root == nil{
//		return
//	}
//	target -= root.Val
//	path = append(path,root.Val)
//	defer func() {
//		path = path[:len(path)-1]
//	}()
//	if root.Left == nil && root.Right == nil && target == 0{
//		*res = append(*res,append([]int(nil),path...))
//
//		return
//	}
//	pathSumRever(root.Left,target,path,res)
//	pathSumRever(root.Right,target,path,res)
//	return
//}
//func firstUniqChar(s string) byte {
//	res := make([]int,26)
//
//	for _,v := range s{
//		res[v-'a']++
//	}
//
//	for i,v := range s{
//		if res[v-'a']==1 {
//			return s[i]
//		}
//	}
//	return s[0]
//}

//func firstUniqChar(s string) byte {
//	res := make(map[byte]int)
//	for i:=0;i<len(s);i++{
//		res[s[i]]++
//	}
//	for i,v := range res{
//		if v == 1{
//			return i
//		}
//	}
//	return s[0]
//}

//func firstUniqChar(s string) byte {
//	res := int32(0)
//	for _,v := range s{
//		res ^= v
//	}
//	s1 := strconv.FormatInt(int64(res),10)
//	s2 := []byte(s1)
//	return s2[0]
//}

//func verifyPostorder(postorder []int) bool {
//	return treeCurend(postorder,0,len(postorder)-1)
//}
//
//func treeCurend(postorder []int,i,j int) bool{
//	if i >= j{
//		return true
//	}
//	p := i
//	for postorder[p] < postorder[j]{
//		p++
//	}
//	m := p
//	for postorder[p] > postorder[j]{
//		p++
//	}
//	return p == j && treeCurend(postorder,i,m-1) && treeCurend(postorder,m,j-1)
//}
//func levelOrder(root *TreeNode) [][]int {
//	if root == nil{
//		return nil
//	}
//	nodes := make([]*TreeNode,0)
//	res := make([][]int,0)
//	nodes = append(nodes,root)
//	f := true
//	for len(nodes) > 0 {
//		len1 := len(nodes)
//		r := make([]int,0)
//		for i := 0; i < len1; i++ {
//			node := nodes[0]
//			nodes = nodes[1:]
//			r = append(r, node.Val)
//			if node.Left != nil {
//				nodes = append(nodes, node.Left)
//			}
//			if node.Right != nil {
//				nodes = append(nodes, node.Right)
//			}
//		}
//		if f{
//			res = append(res,r)
//		}else {
//			for i:=0;i<len(r)/2;i++{
//				r[i],r[len(r)-i-1] = r[len(r)-i-1],r[i]
//			}
//			res = append(res,r)
//		}
//		f = !f
//	}
//	return res
//}
//func findNthDigit(n int) int {
//	digit,start,count := 1,1,9
//
//	for n > count{
//		n -= count
//		start *= 10
//		digit++
//		count = 9 * start * digit
//	}
//	num := start + (n-1)/digit
//	return int(strconv.Itoa(num)[(n-1)%digit]-'0')
//}
//type TreeNode struct {
//	     Val int
//	     Left *TreeNode
//	     Right *TreeNode
// }
//func levelOrder(root *TreeNode) [][]int {
//	if root == nil{
//		return nil
//	}
//	nodes := make([]*TreeNode,0)
//	res := make([][]int,0)
//	nodes = append(nodes,root)
//
//
//	for len(nodes) > 0 {
//		len1 := len(nodes)
//		r := make([]int,0)
//		for i := 0; i < len1; i++ {
//			node := nodes[0]
//			nodes = nodes[1:]
//			r = append(r, node.Val)
//			if node.Left != nil {
//				nodes = append(nodes, node.Left)
//			}
//			if node.Right != nil {
//				nodes = append(nodes, node.Right)
//			}
//		}
//		res = append(res,r)
//	}
//	return res
//}
//func levelOrder(root *TreeNode) [][]int {
//	res := make()
//	if root == nil{
//		return nil
//	}
//
//}
//func levelOrder(root *TreeNode) []int {
//	if root == nil{
//		return nil
//	}
//	nodes := make([]*TreeNode,0)
//	res := make([]int,0)
//	nodes = append(nodes,root)
//	lengh := len(nodes)
//
//	for lengh > 0 {
//		len1 := len(nodes)
//		for i := 0; i < len1; i++ {
//			node := nodes[0]
//			nodes = nodes[1:]
//			res = append(res, node.Val)
//			if node.Left != nil {
//				nodes = append(nodes, node.Left)
//			}
//			if node.Right != nil {
//				nodes = append(nodes, node.Right)
//			}
//		}
//	}
//	return res
//}
//func majorityElement(nums []int) int {
//	res := make(map[int]int)
//
//	for i:=0;i<len(nums);i++{
//		res[nums[i]]++
//	}
//	for i,v := range res{
//		if v >= len(nums)/2{
//			return i
//		}
//	}
//	return -1
//}
//func countDigitOne(n int) int {
//	low := 0
//	high := n/10
//	digit := 1
//	cur := n%10
//	res := 0
//	for cur != 0 || high != 0{
//		if cur == 0{
//			res += high * digit
//		}else if cur == 1{
//			res += high * digit + low + 1
//		}else{
//			res += (high + 1) * digit
//		}
//		low += cur * digit
//		digit *= 10
//		cur = high % 10
//		high = high /10
//	}
//	return res
//}

//func countDigitOne(n int) int {
//	res := 0
//	for i:=1;i<=n;i++{
//		res += sum1(i)
//	}
//	return res
//}
//func sum1(x int)int{
//	num := 0
//	for x != 0{
//		if x % 10 == 1{
//			num++
//		}
//		x = x/10
//	}
//return num
//}

//func permutation(s string) []string {
//	if len(s) == 0{
//		return nil
//	}
//	result := make([]string,0)
//	sli := make([]string,len(s))
//	for i:= 0;i<len(s);i++{
//		sli[i] = string(s[i])
//	}
//	list := ""
//	visited := make([]bool,len(s))
//	sort.Strings(sli)
//	fmt.Println(len(sli))
//	backtractk(sli,visited,list,&result)
//	return result
//}
//
//func backtractk(s []string,visited []bool,list string,result *[]string){
//	if len(list) == len(s){
//		*result = append(*result,list)
//		return
//	}
//	for i:=0;i<len(s);i++{
//		if visited[i]{
//			continue
//		}
//		if i != 0 && s[i] == s[i-1] && !visited[i-1]{
//			continue
//		}
//		list += s[i]
//		visited[i] = true
//		backtractk(s,visited,list,result)
//		visited[i] = false
//		list = list[:len(list)-1]
//	}
//}

//func validateStackSequences(pushed []int, popped []int) bool {
//	stack := make([]int,0)
//	j:=0
//	for i:=0;i<len(pushed);i++{
//		stack = append(stack,pushed[i])
//		fmt.Println(len(stack))
//		for stack[len(stack)-1] == popped[j]{
//			j++
//			stack = stack[:len(stack)-1]
//		}
//	}
//	if len(stack) == 0{
//		return true
//	}
//	return false
//}

// func validateStackSequences(pushed []int, popped []int) bool {
// 	if len(pushed) == 0 && len(popped) != 0{
// 		return false
// 	}
// 	f:=make([][]bool,len(popped)+1)
// 	for i:=0;i<len(f);i++{
// 		f[i] = make([]bool,len(pushed)+1)
// 	}
// 	f[0][0] = true
// 	for i:=0;i<len(f);i++{
// 		for j:=1;j<len(f[0]);j++{
// 			if i == 0{
// 				f[0][j] = true
// 				continue
// 			}else if pushed[i-1] == popped[j-1] && f[i-1][j] == true{
// 				f[i][j] = f[i][j] || true
// 			}else if pushed[i-1] != popped[j-1] && (f[i][j-1]==true || (j-i>=0 && popped[i-1] == pushed[i-1])){
// 				f[i][j] = f[i][j] || true
// 			}

// 		}
// 		fmt.Println(f)
// 	}
// 	return f[len(f)-1][len(f[0])-1]
// }
// func maxSubArray(nums []int) int {
// 	f := make([]int,len(nums))
// 	f[0] = nums[0]
// 	max := f[0]
// 	for i:=1;i<len(nums);i++{
// 		f[i] = max(nums[i],f[i-1]+nums[i])
// 		if f[i] > max{
// 			max = f[i]
// 		}
// 	}
// 	return max
// }

// type MedianFinder struct {
// 	stack  []int
// 	medium float64
// }

// /** initialize your data structure here. */
// func Constructor() MedianFinder {
// 	medianfinder := MedianFinder{
// 		stack: make([]int, 0),
// 	}
// 	return medianfinder
// }

// func (this *MedianFinder) AddNum(num int) {
// 	if len(this.stack) == 0 {
// 		this.stack = append(this.stack, num)
// 		return
// 	}
// 	left := 0
// 	right := len(this.stack) - 1
// 	for left+1 < right {
// 		mid := left + (right-left)/2
// 		if this.stack[mid] < num {
// 			left = mid
// 		} else {
// 			right = mid
// 		}
// 	}
// 	if this.stack[right] < num {
// 		this.stack = append(this.stack[:right+1],append([]int{num},this.stack[right+1:]...)...)
// 	} else if this.stack[left] > num {
// 		this.stack = append(this.stack[:left],append([]int{num},this.stack[left:]...)...)
// 	}else{
// 		this.stack = append(this.stack[:right],append([]int{num},this.stack[right:]...)...)
// 	}

// }

// func (this *MedianFinder) FindMedian() float64 {
// 	if len(this.stack)%2 == 0 {
// 		this.medium = float64((this.stack[len(this.stack)/2] + this.stack[len(this.stack)/2-1])) / 2
// 	} else {
// 		this.medium = float64(this.stack[len(this.stack)/2])
// 	}
// 	return this.medium
// }

// type MinStack struct {
// 	stack []int
// 	min   []int
// }

/** initialize your data structure here. */
// func Constructor() MinStack {
// 	minstack := MinStack{
// 		stack: make([]int, 0),
// 		min:   make([]int, 0),
// 	}
// 	return minstack
// }

// func (this *MinStack) Push(x int) {
// 	if x < this.min[len(this.min)-1] {
// 		this.min = append(this.min, x)
// 	} else {
// 		this.min = append(this.min, this.min[len(this.min)-1])
// 	}
// 	this.stack = append(this.stack, x)
// }

// func (this *MinStack) Pop() {
// 	this.stack = this.stack[:len(this.stack)-1]
// 	this.min = this.min[:len(this.min)-1]
// }

// func (this *MinStack) Top() int {
// 	return this.stack[len(this.stack)-1]
// }

// func (this *MinStack) Min() int {
// 	return this.min[:len(this.min)-1]
// }

// func copyRandomList(head *Node) *Node {
// 	if head == nil {
// 		return head
// 	}

// 	for node := head; node != nil; node = node.Next.Next {
// 		temp := &Node{
// 			Val:  node.Val,
// 			Next: node.Next,
// 		}
// 		node.Next = temp
// 	}
// 	for node := head; node != nil; node = node.Next.Next {
// 		if node.Random != nil {
// 			node.Next.Random = node.Random.Next
// 		}
// 	}

// 	Prenode := head.Next
// 	for node := head; node != nil; node = node.Next {
// 		temp := node.Next
// 		node.Next = node.Next.Next
// 		if temp.Next != nil {
// 			temp.Next = temp.Next.Next
// 		}
// 	}
// 	return Prenode
// }

// func deleteNode(head *ListNode, val int) *ListNode {
// 	if head == nil{
// 		return head
// 	}
// 	var dump *ListNode
// 	dump.Next = head
// 	pre = dump
// 	for head != nil{
// 		if head.Val == val{
// 			pre.Next = head.Next
// 			return dump.Next
// 		}
// 		pre= head
// 		head = head.Next
// 	}
// 	return dump.Next
// }
// func reverseList(head *ListNode) *ListNode {
// 	if head == nil {
// 		return head
// 	}
// 	var pre *ListNode
// 	for head != nil {
// 		temp := head.Next
// 		head.Next = pre
// 		pre = head
// 		head = temp
// 	}
// 	return head.Next
// }

// func isMatch(s string, p string) bool {
// 	m, n := len(s), len(p)

// 	res := make([][]bool, m+1)
// 	for i := 0; i <= m; i++ {
// 		res[i] = make([]bool, n+1)
// 	}
// 	matches := func(i, j int) bool {
// 		if i == 0 {
// 			return false
// 		} else if p[j-1] == '.' {
// 			return true
// 		}
// 		return s[i-1] == p[j-1]
// 	}
// 	res[0][0] = true
// 	for i := 0; i <= m; i++ {
// 		for j := 1; j <= n; j++ {
// 			if p[j-1] == '*' {
// 				res[i][j] = resres[i][j-2]
// 				if matches(i, j-1) { //传入i,j-1，表示当前s字符与p的上个字符比较
// 					res[i][j] = res[i][j] || res[i-1][j]
// 				}
// 			} else if matches(i, j) {
// 				res[i][j] = res[i][j] || res[i-1][j-1]
// 			}
// 		}
// 	}
// 	return res[m][n]
// }

// func isMatch(s string, p string) bool {
// 	if len(s) != 0 && len(p) == 0 {
// 		return false
// 	}
// 	index := 0
// 	for len(p) != 0 {
// 		if p[index] == s[index] {
// 			index++
// 			continue
// 		} else {
// 			if p[index] == '.' {
// 				index++
// 				continue
// 			} else if p[index] == '*' && p[index-1] == s[index] {
// 				temp := index - 1
// 				index++
// 				for index < len(p) && s[index] == s[temp] && p[index] != s[index] {
// 					index++
// 				}

// 			} else {
// 				index += 1
// 				if index < len(p) && p[index] == '*' {
// 					continue
// 				} else {
// 					return false
// 				}
// 			}
// 		}
// 	}
// 	if index == len(p) && index
// 	return true
// }0

// func printNumbers(n int) []int {
// 	res := make([]int, 0)
// 	temp := 1
// 	for n != 0 {
// 		temp *= 10
// 		n--
// 	}
// 	for i := 1; i < temp; i++ {
// 		res = append(res, i)
// 	}
// 	return res
// }

// func myPow(x float64, n int) float64 {
// 	if n == 0 {
// 		return 0
// 	}
// 	var res float64 = 1
// 	if n < 0 {
// 		x = 1 / x
// 		n = -n
// 	}
// 	for n != 0 {
// 		if n&1 == 1 {
// 			res *= x
// 		}
// 		x *= x
// 		n = n >> 1
// 	}
// 	return res
// }

// func isNumber(s string) bool {
// 	if len(s) == 0 {
// 		return false
// 	}
// 	stack := make([]byte, 0)

// 	for len(s) != 0 {
// 		switch s[0] {
// 		case ' ':

// 		case '+':
// 			if len(stack) != 0 && (stack[len(stack)-1] != 'e' || stack[len(stack)-1] != 'E') {

// 				return false
// 			}
// 			stack = append(stack, s[0])
// 		case '-':
// 			if len(stack) != 0 && stack[len(stack)-1] != 'e' && stack[len(stack)-1] != 'E' {
// 				fmt.Println("haha", string(stack[len(stack)-1]))
// 				return false
// 			}
// 			stack = append(stack, s[0])
// 		case '.':
// 			if len(stack) == 0 {
// 				return false
// 			}
// 			for i := 0; i < len(stack); i++ {
// 				if stack[i] == 'e' || stack[i] == 'E' || stack[i] == '.' {
// 					return false
// 				}
// 			}
// 			stack = append(stack, s[0])
// 		case 'e':
// 			if len(stack) == 0 {
// 				return false
// 			}
// 			v, err := strconv.Atoi(string(stack[len(stack)-1]))
// 			if err != nil || v < 0 || v > 9 {
// 				return false
// 			}

// 			stack = append(stack, s[0])
// 		case 'E':
// 			if len(stack) == 0 {
// 				return false
// 			}
// 			v, err := strconv.Atoi(string(stack[len(stack)-1]))
// 			if err != nil || v < 0 || v > 9 {
// 				return false
// 			}
// 			stack = append(stack, s[0])
// 		default:
// 			v, err := strconv.Atoi(string(s[0]))
// 			if err != nil {

// 				return false
// 			} else if v < 0 || v > 9 {
// 				return false
// 			}
// 			stack = append(stack, s[0])
// 		}
// 		s = s[1:]
// 		fmt.Println(stack, s, len(s))
// 	}
// 	if len(stack) == 0 || stack[len(stack)-1] == 'e' || stack[len(stack)-1] == 'E' || stack[len(stack)-1] == '.' {
// 		return false
// 	}
// 	return true
// }

// func spiralOrder(matrix [][]int) []int {

// 	if len(matrix) == 0 || len(matrix[0]) == 0 {
// 		return nil
// 	}
// 	l := 0
// 	r := len(matrix[0]) - 1
// 	t := 0
// 	b := len(matrix) - 1
// 	res := make([]int, len(matrix)*len(matrix[0]))
// 	index := 0
// 	for {
// 		for lr := l; lr <= r; lr++ {
// 			res[index] = matrix[t][lr]
// 			index++
// 		}
// 		t++
// 		if t > b {
// 			break
// 		}
// 		for tb := t; tb <= b; tb++ {
// 			res[index] = matrix[tb][r]
// 			index++
// 		}
// 		r--
// 		if l > r {
// 			break
// 		}

// 		for rl := r; rl >= l; rl-- {
// 			res[index] = matrix[b][rl]
// 			index++
// 		}
// 		b--
// 		if t > b {
// 			break
// 		}

// 		for bt := b; bt >= t; bt-- {
// 			res[index] = matrix[bt][l]
// 			index++
// 		}
// 		l++
// 		if l > r {
// 			break
// 		}
// 	}
// 	return res
// }

// func getKthFromEnd(head *ListNode, k int) *ListNode {
// 	if head == nil || head.Next == nil{
// 		return head
// 	}
// 	first := head
// 	two := head
// 	for i:=0;i<k;i++{
// 		two = two.Next
// 	}
// 	for two != nil{
// 		first = first.Next
// 		two = two.Next
// 	}
// 	return first
// }
// func getKthFromEnd(head *ListNode, k int) *ListNode {
// 	if head == nil || head.Next == nil{
// 		return head
// 	}
// 	nums := 0
// 	temp := head
// 	start := head
// 	for temp != nil{
// 		nums++
// 		temp = temp.Next
// 	}
// 	for i:=0;i<nums-k;i++{
// 		start = start.Next
// 	}
// 	return start
// }

// func hammingWeight(num uint32) int {
// 	if num == 0 {
// 		return 0
// 	}
// 	res := 0
// 	for num != 0 {
// 		if num&1 == 1 {
// 			res++
// 		}
// 		num = num >> 1

// 	}
// 	return res
// }

// func exchange(nums []int) []int {
// 	start := 0
// 	end := len(nums) - 1
// 	if len(nums) == 0 {
// 		return nums
// 	}
// 	for end != start {
// 		if nums[end]%2 != 0 {
// 			nums[start], nums[end] = nums[end], nums[start]
// 			start++
// 			continue
// 		}
// 		end--
// 	}
// 	return nums
// }

// func isSubStructure(A *TreeNode, B *TreeNode) bool {
// 	if A == nil {
// 		return false
// 	}
// 	nodes := make([]*TreeNode, 0)
// 	nodes = append(nodes, A)

// 	for len(nodes) != 0 {
// 		length := len(nodes)
// 		for i := 0; i < length; i++ {
// 			node := nodes[0]
// 			nodes = nodes[1:]
// 			if node.Val == B.Val {
// 				b := reverSubStructure(node, B)
// 				if b {
// 					return true
// 				}
// 			}
// 			if node.Left != nil {
// 				nodes = append(nodes, node.Left)
// 			}
// 			if node.Right != nil {
// 				nodes = append(nodes, node.Right)
// 			}
// 		}
// 	}
// 	return false
// }

// func reverSubStructure(A *TreeNode, B *TreeNode) bool {
// 	if A.Val == B.Val && B.Left == nil && B.Right == nil {
// 		return true
// 	} else if (B.Left != nil && A.Left == nil) || (B.Right != nil && A.Right == nil) || A.Val != B.Val {
// 		return false
// 	} else if B == nil {
// 		return true
// 	}
// 	bleft := reverSubStructure(A.Left, B.Left)
// 	bright := reverSubStructure(A.Right, B.Right)
// 	return bleft && bright
// }

// func isSymmetric(root *TreeNode) bool {
// 	if root == nil {
// 		return true
// 	}
// 	return revermetric(root.Left, root.Right)
// }
// func revermetric(left *TreeNode, right *TreeNode) bool {
// 	if left == nil && right == nil {
// 		return true
// 	} else if left == nil || right == nil || left.Val != right.Val {
// 		return false
// 	}
// 	return revermetric(left.Right, right.Left) && revermetric(left.Left, right.Right)
// }

// func mirrorTree(root *TreeNode) *TreeNode {
// 	if root == nil {
// 		return nil
// 	}
// 	node := &TreeNode{
// 		Val:   root.Val,
// 		Left:  nil,
// 		Right: nil,
// 	}
// 	node.Left = mirrorTree(root.Right)
// 	node.Right = mirrorTree(root.Left)
// 	return node
// }

// func cuttingRope(n int) int {

// }

// func cuttingRope(n int) int {
// 	f := make([]int, n+1)
// 	f[2] = 1
// 	for i := 3; i < n+1; i++ {
// 		for j := 2; j < i; j++ {
// 			f[i] = max(j*(i-j), max(f[i], f[i-j]*j))
// 		}
// 	}
// 	return f[n]
// }

// func cuttingRope(n int) int {
// 	v := float64(n % 3)
// 	if n < 4 {
// 		return n - 1
// 	}
// 	res := int64(1)
// 	m := int64(1000000007)

// 	if v == 0 {
// 		for i := n; i > 0; i -= 3 {
// 			res = (res * 3) % m
// 		}
// 	} else if v == 1 {
// 		for i := n; i > 4; i -= 3 {
// 			res = (res * 3) % m
// 		}
// 		res = (res * 4) % m
// 	} else if v == 2 {
// 		for i := n; i > 5; i -= 3 {
// 			res = (res * 3) % m
// 		}
// 		res = (res * 2) % m
// 	}
// 	return int(res)
// }

// type TreeNode struct {
// 	Val   int
// 	Left  *TreeNode
// 	Right *TreeNode
// }

// func buildTree(preorder []int, inorder []int) *TreeNode {
// 	if len(preorder) == 0 {
// 		return nil
// 	}

// 	root := &TreeNode{
// 		Val:   preorder[0],
// 		Left:  nil,
// 		Right: nil,
// 	}
// 	i := 0
// 	for ; i < len(inorder); i++ {
// 		if inorder[i] == root.Val {
// 			break
// 		}
// 	}
// 	root.Left = buildTree(preorder[1:len(inorder[0:i])+1], inorder[0:i])
// 	root.Right = buildTree(preorder[len(inorder[0:i])+1:], inorder[i+1:])
// 	return root
// }

// func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
// 	if l1 == nil {
// 		return l2
// 	} else if l2 == nil {
// 		return l1
// 	}
// 	head := &ListNode{}
// 	temp := head
// 	for l1 != nil && l2 != nil {
// 		if l1.Val > l2.Val {
// 			temp.Next = l2
// 			temp = temp.Next
// 		} else {
// 			temp.Next = l1
// 			temp = temp.Next
// 		}
// 	}
// 	if l1 != nil {
// 		temp.Next = l1
// 	} else if l2 != nil {
// 		temp.Next = l2
// 	}
// 	return head.Next
// }

// type ListNode struct {
// 	Val  int
// 	Next *ListNode
// }

// func reversePrint(head *ListNode) []int {
// 	res := make([]int, 0)
// 	if head == nil {
// 		return res
// 	}

// 	dump := &ListNode{}
// 	dump.Next = head
// 	pre := dump
// 	for head != nil {
// 		temp := head.Next
// 		head.Next = pre
// 		pre = head
// 		head = temp
// 	}

// 	for pre != nil {
// 		res = append(res, pre.Val)
// 		pre = pre.Next
// 	}
// 	return res
// }

// func movingCount(m int, n int, k int) int {
// 	if m == 0 || n == 0 {
// 		return 0
// 	}
// 	f := make([][]int, m)
// 	for i := 0; i < m; i++ {
// 		f[i] = make([]int, n)
// 	}

// 	return dspmoving(f, k, 0, 0)
// }

// func sumPos(n int) int {
// 	var sum int
// 	for n != 0 {
// 		sum += n % 10
// 		n = n / 10
// 	}
// 	return sum
// }

// func dspmoving(f [][]int, k, i, j int) int {
// 	if i < 0 || j < 0 || i > len(f)-1 || j > len(f[0])-1 || f[i][j] == 1 || sumPos(i)+sumPos(j) > k {
// 		return 0
// 	}

// 	f[i][j] = 1
// 	sum := 1
// 	sum += dspmoving(f, k, i+1, j)
// 	sum += dspmoving(f, k, i-1, j)
// 	sum += dspmoving(f, k, i, j+1)
// 	sum += dspmoving(f, k, i, j-1)

// 	return sum
// }

// func exist(board [][]byte, word string) bool {
// 	if len(board) == 0 || len(board[0]) == 0 {
// 		return false
// 	}
// 	for i := 0; i < len(board); i++ {
// 		for j := 0; j < len(board[0]); j++ {
// 			res := dspexist(board, word, i, j, 0)
// 			//fmt.Println(res, i, j)
// 			if res {
// 				return true
// 			}
// 		}
// 	}
// 	return false
// }

// func dspexist(board [][]byte, word string, i, j, n int) bool {
// 	if i < 0 || i > len(board)-1 || j < 0 || j > len(board[0])-1 || board[i][j] != word[n] {
// 		//fmt.Println("haha", board[i][j], word[n])
// 		return false
// 	}
// 	if n == len(word)-1 {
// 		return true
// 	}
// 	board[i][j] = ' '
// 	res := dspexist(board, word, i-1, j, n+1) || dspexist(board, word, i+1, j, n+1) || dspexist(board, word, i, j-1, n+1) || dspexist(board, word, i, j+1, n+1)
// 	board[i][j] = word[n]
// 	return res
// }

// func exist(board [][]byte, word string) bool {
// 	if len(board) == 0 || len(board[0]) == 0{
// 		return false
// 	}
// 	temp := word[0]
// 	target := make(map[string]int)
// 	res := make([][]byte,len(board)+1)
// 	target[temp] = 1
// 	k := 2
// 	for i:=0;i<len(res);i++{
// 		res[i] = make([]byte,len(board)+1)
// 		res[0][i] = 0
// 		res[i][0] = 0
// 	}
// 	for i:=1;i<len(word);i++{
// 		if word[i] == word[i-1]{
// 			continue
// 		}
// 		target[i] = k
// 		k++
// 		temp = target[i]
// 	}
// 	for i:=0;i<len(board);i++{
// 		for j:=0;j<len(board[0]);j++{
// 			v,ok := board[i][j]
// 			if !ok{
// 				continue
// 			}
// 			if i-1 >= 0 && res[i-1][j] == v-1{
// 				res[i][j] = v
// 			}else j - 1>=0 && res[i][j-1] == v-1{
// 				res[]
// 			}
// 		}
// 	}
// }
// func minArray(numbers []int) int {
// 	if len(numbers) == 0 {
// 		return 0
// 	}
// 	left := 0
// 	right := len(numbers) - 1
// 	for left+1 < right {
// 		for numbers[left] == numbers[left+1] {
// 			left++
// 		}
// 		for numbers[right] == numbers[right-1] {
// 			right--
// 		}
// 		middle := left + (right-left)/2
// 		if numbers[middle] > numbers[right] {
// 			left = middle
// 		} else {
// 			right = middle
// 		}
// 	}
// 	if numbers[left] < numbers[right] {
// 		return numbers[left]
// 	} else {
// 		return numbers[right]
// 	}
// }

// func numWays(n int) int {
// 	if n == 0 {
// 		return 0
// 	}
// 	res := make([]int, n+3)
// 	res[1] = 1
// 	res[2] = 2
// 	for i := 3; i <= n; i++ {
// 		res[i] = (res[i-1] + res[i-2]) % 1000000007
// 	}
// 	return res[n]
// }

// func findNumberIn2DArray(matrix [][]int, target int) bool {
// 	if len(matrix) == 0 || len(matrix[0]) == 0 {
// 		return false
// 	}
// 	row := 0
// 	col := len(matrix) - 1
// 	for row < len(matrix) && col >= 0 {
// 		if matrix[row][col] == target {
// 			return true
// 		} else if matrix[row][col] < target {
// 			row++
// 		} else {
// 			col--
// 		}
// 	}
// 	return false
// }

// func findNumberIn2DArray(matrix [][]int, target int) bool {
// 	if len(matrix) == 0 || len(matrix[0]) == 0 {
// 		return false
// 	}
// 	for i := 0; i < len(matrix); i++ {
// 		if TwoSort(matrix[i], target) {
// 			return true
// 		}
// 	}
// 	return false
// }

// func TwoSort(mat []int, target int) bool {
// 	left := 0
// 	right := len(mat) - 1
// 	for left+1 < right {
// 		mid := left + (right-left)/2
// 		if mat[mid] == target {
// 			return true
// 		} else if mat[mid] > mat[left] {
// 			right = mid
// 		} else {
// 			left = mid
// 		}
// 	}
// 	if mat[left] == target || mat[right] == target {
// 		return true
// 	}
// 	return false
// }

// func findRepeatNumber(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	sort.Ints(nums)
// 	res := make([]int, 0)
// 	temp := 0
// 	for i := 0; i < len(nums)-1; i++ {
// 		if nums[i] == nums[i+1] {
// 			temp = nums[i]
// 			res = append(res, nums[i])
// 			break
// 		}
// 	}
// 	return temp
// }

// func fib(n int) int {
// 	f := make([]int, n+2)
// 	f[0] = 0
// 	f[1] = 1
// 	for i := 2; i <= n; i++ {
// 		f[i] = (f[i-1] + f[i-2]) % 1000000007
// 	}
// 	return f[n]
// }

// type CQueue struct {
// 	queue []int
// }

// func Constructor() CQueue {
// 	c := CQueue{}
// 	c.queue = make([]int, 0)
// 	return c
// }

// func (this *CQueue) AppendTail(value int) {
// 	this.queue = append(this.queue, value)
// }

// func (this *CQueue) DeleteHead() int {
// 	if len(this.queue) != 0 {
// 		return this.queue[0]
// 	}
// 	return -1
// }

// func jump(nums []int) int {
// 	end := 0
// 	index := 0
// 	temp := 0
// 	if len(nums) == 1 {
// 		return 0
// 	}
// 	for i := 0; i < len(nums); i++ {
// 		temp = max(temp, nums[i]+i)
// 		if end == i {
// 			end = temp
// 			index++
// 		}
// 	}
// 	return index

// }

// func canJump(nums []int) bool {
// 	if len(nums) == 0 {
// 		return false
// 	}
// 	end := nums[0]
// 	jumpmax := 0
// 	for i := 0; i < len(nums); i++ {
// 		jumpmax = max(nums[i]+i, jumpmax)
// 		if i == end {
// 			end = jumpmax
// 			if end >= len(nums)-1 {
// 				return true
// 			}
// 		}

// 	}
// 	return end >= len(nums)-1
// }

// func climbStairs(n int) int {
// 	f := make(map[int]int)
// 	f[1] = 1
// 	f[2] = 2
// 	for i := 3; i <= n; i++ {
// 		f[i] = f[i-1] + f[i-1]
// 	}
// 	return f[n]
// }

// func uniquePaths(m int, n int) int {
// 	result := make([][]int, m)
// 	for i := 0; i < m; i++ {
// 		result[i] = make([]int, n)
// 	}

// 	for i := 0; i < m; i++ {
// 		for j := 0; j < n; j++ {
// 			if i == 0 {
// 				result[i][j] = 1
// 			} else if j == 0 {
// 				result[i][j] = 1
// 			} else {
// 				result[i][j] = result[i-1][j] + result[i][j-1]
// 			}
// 		}
// 	}
// 	return result[m-1][n-1]
// }

// func minPathSum(grid [][]int) int {
// 	if len(grid) == 0 || len(grid[0]) == 0 {
// 		return 0
// 	}
// 	target := make([][]int, len(grid))
// 	for i := 0; i < len(grid); i++ {
// 		target[i] = make([]int, len(grid[i]))
// 	}

// 	for i := 0; i < len(grid); i++ {
// 		for j := 0; j < len(grid[i]); j++ {
// 			if i == 0 && j == 0 {
// 				target[i][j] = grid[0][0]
// 			} else if i == 0 {
// 				target[i][j] = target[i][j-1] + grid[i][j]
// 			} else if j == 0 {
// 				target[i][j] = target[i-1][j] + grid[i][j]
// 			} else {
// 				target[i][j] = min(target[i-1][j]+grid[i][j], target[i][j-1]+grid[i][j])
// 			}
// 		}
// 	}
// 	return target[len(grid)-1][len(grid[0])-1]
// }

// func permuteUnique(nums []int) [][]int {
// 	result := make([][]int, 0)
// 	list := make([]int, 0)
// 	visited := make([]bool, len(nums))
// 	Uniquereve(nums, &result, list, visited)
// 	return result
// }

// func Uniquereve(nums []int, result *[][]int, list []int, visited []bool) {
// 	if len(list) == len(nums) {
// 		ans := make([]int, len(list))
// 		copy(ans, list)
// 		*result = append(*result, ans)
// 		return
// 	}

// 	for i := 0; i < len(nums); i++ {
// 		if visited[i] {
// 			continue
// 		}
// 		if i != 0 && nums[i] == nums[i-1] && visited[i-1] == false {
// 			continue
// 		}
// 		list = append(list, nums[i])
// 		visited[i] = true
// 		Uniquereve(nums, result, list, visited)
// 		visited[i] = false
// 		list = list[0 : len(list)-1]
// 	}
// }

// func permute(nums []int) [][]int {
// 	result := make([][]int, 0)
// 	list := make([]int, 0)
// 	visited := make([]bool, len(nums))
// 	allList(nums, &result, list, visited)
// 	return result
// }

// func allList(nums []int, result *[][]int, list []int, visited []bool) {
// 	if len(list) == len(nums) {
// 		ans := make([]int, len(list))
// 		copy(ans, list)
// 		*result = append(*result, ans)
// 		return
// 	}
// 	for i := 0; i < len(nums); i++ {
// 		if visited[i] {
// 			continue
// 		}
// 		list = append(list, nums[i])
// 		visited[i] = true
// 		allList(nums, result, list, visited)
// 		visited[i] = false
// 		list = list[0 : len(list)-1]
// 	}
// }

// func subsetsWithDup(nums []int) [][]int {
// 	result := make([][]int,0)
// 	list := make([]int,0)
// 	Subreverse(nums,&result,list,0)
// 	return result
// }

// func Subreverse(nums []int,result *[][]int,list []int,n int){
// 	ans := make([]int,len(list))
// 	copy(ans,list)
// 	*result  = append(*result,ans)

// 	for i:=n;i<len(nums);i++{
// 		if i != n && nums[i] == nums[i-1]{
// 			continue
// 		}
// 		Subreverse(nums,result,list,i+1)
// 		list = list[:len(list)-1]
// 	}

// }

// func subsets(nums []int) [][]int {
// 	result := make([][]int, 0)
// 	list := make([]int, 0)
// 	subrevers(nums, &result, list, 0)
// 	return result
// }
// func subrevers(nums []int, result *[][]int, list []int, n int) {
// 	ans := make([]int, len(list))
// 	copy(ans, list)
// 	*result = append(*result, ans)

// 	for i := n; i < len(nums); i++ {
// 		list = append(list, nums[i])
// 		subrevers(nums, result, list, i+1)
// 		list = list[0 : len(list)-1]
// 	}
// }

//
// type res struct {
// 	height int
// 	ok     bool
// }

// func isBalanced(root *TreeNode) bool {
// 	result := reverseHeight(root)
// 	return result.ok
// }

// func reverseHeight(root *TreeNode) res {
// 	result := res{
// 		ok: true,
// 	}
// 	if root == nil {
// 		return result
// 	}
// 	left := reverseHeight(root.Left)
// 	right := reverseHeight(root.Right)
// 	if !left.ok || !right.ok {
// 		result.ok = false
// 		return result
// 	}
// 	if left.height-right.height > 1 || right.height-left.height > 1 {
// 		result.ok = false
// 		return result
// 	}
// 	result.height = max(left.height, right.height) + 1
// 	return result
// }

// func deleteNode(root *TreeNode, key int) *TreeNode {
// 	if root.Val == key {
// 		if root.Right == nil {
// 			return root.Left
// 		}
// 		root1 := reverse(root.Right)
// 		root1.Left = root.Left
// 		return root.Right
// 	}

// 	if root.Val < key {
// 		right := deleteNode(root.Right, key)
// 		root.Right = right
// 	} else {
// 		left := deleteNode(root.Left, key)
// 		root.Left = left
// 	}
// 	return root

// }

// func reverse(root *TreeNode) *TreeNode {
// 	if root == nil {
// 		return root
// 	}
// 	left := reverse(root.Left)
// 	if left == nil {
// 		return root
// 	}
// 	return left

// }

// func insertIntoBST(root *TreeNode, val int) *TreeNode {
// 	if root == nil {
// 		return &TreeNode{Val:val}
// 	}

// 	if root.Val > val {
// 		root.Left := insertIntoBST(root.Left, val)
// 	} else if root.Val < val {
// 		root.Right := insertIntoBST(root.Right, val)
// 	}
// 	return res
// }

// func Insertrever(root *TreeNode, val int) *TreeNode {

// }

// type TreeNode struct {
// 	Val   int
// 	Left  *TreeNode
// 	Right *TreeNode
// }

// type res struct {
// 	minT int
// 	maxT int
// 	ok   bool
// }

// func isValidBST(root *TreeNode) bool {
// 	r := reverse(root)
// 	return r.ok
// }

// func reverse(root *TreeNode) res {
// 	result := res{
// 		ok:   true,
// 		minT: 1 << 32,
// 		maxT: -(1 << 32),
// 	}
// 	if root == nil {
// 		return result
// 	}

// 	leftres := reverse(root.Left)
// 	rightres := reverse(root.Right)

// 	if !leftres.ok || !rightres.ok {
// 		result.ok = false
// 		return result
// 	}
// 	if leftres.minT == 1<<32 {
// 		result.minT = root.Val
// 	}
// 	if rightres.maxT == -(1 << 32) {
// 		result.maxT = root.Val
// 	}
// 	if root.Val < leftres.maxT || root.Val > rightres.minT {
// 		result.ok = false
// 		return result
// 	}
// 	result.maxT = max(root.Val, rightres.maxT)
// 	result.minT = min(leftres.minT, root.Val)
// 	return result
// }

// func lengthOfLongestSubstring(s string) int {
// 	win := make(map[byte]int)
// 	res := 1
// 	left, right := 0,0

// 	var c byte
// 	for right < len(s) {
// 		c = s[right]
// 		right++

// 		for win[c] > 1 {
// 			d := s[left]
// 			left++
// 			win[d]--
// 		}
// 		res = max(res, right-left)
// 	}
// 	return res
// }

// func findAnagrams(s string, p string) []int {
// 	need := make(map[byte]int)
// 	win := make(map[byte]int)

// 	left, right, match := 0, 0, 0

// 	for i := 0; i < len(p); i++ {
// 		need[p[i]]++
// 	}
// 	//fmt.Println(need)
// 	res := make([]int, 0)
// 	var c byte
// 	for right < len(s) {
// 		c = s[right]
// 		right++
// 		if need[c] != 0 {
// 			win[c]++
// 			if win[c] == need[c] {
// 				match++
// 			}
// 		}

// 		for right-left >= len(p) {
// 			if match == len(need) {
// 				res = append(res, left)
// 			}
// 			c = s[left]
// 			if need[c] != 0 {
// 				if win[c] == need[c] {
// 					match--
// 				}
// 				win[c]--
// 			}
// 			left++
// 		}

// 	}
// 	return res
// }

// func checkInclusion(s1 string, s2 string) bool {
// 	need := make(map[byte]int)
// 	win := make(map[byte]int)
// 	match, left, right := 0, 0, 0

// 	for i := 0; i < len(s1); i++ {
// 		need[s1[i]]++
// 	}

// 	var c byte

// 	for right < len(s2) {
// 		c = s2[right]
// 		right++

// 		if need[c] != 0 {
// 			win[c]++
// 			if win[c] == need[c] {
// 				match++
// 			}
// 		}

// 		for right-left <= len(s1) {
// 			if match == len(need) {
// 				return true
// 			}

// 			c = s2[left]
// 			left++
// 			if need[c] != 0 {
// 				if win[c] == need[c] {
// 					match--
// 				}
// 				win[c]--
// 			}
// 		}
// 	}
// 	return false
// }

// func minWindow(s string, t string) string {
// 	need := make(map[byte]int)
// 	win := make(map[byte]int)
// 	minwin := 1 << 32
// 	match := 0
// 	start := 0
// 	end := 0

// 	left := 0
// 	right := 0

// 	for i := 0; i < len(t); i++ {
// 		need[t[i]]++
// 	}
// 	for right < len(s) {
// 		c := s[right]
// 		right++

// 		if need[c] != 0 {
// 			win[c]++
// 			if win[c] == need[c] {
// 				match++
// 			}
// 		}
// 		for match == len(need) {
// 			if minwin > right-left {
// 				start = left
// 				end = right
// 				minwin = right - left
// 			}

// 			c := s[left]
// 			left++

// 			if need[c] != 0 {
// 				win[c]--
// 				if win[c] < need[c] {
// 					match--
// 				}
// 			}
// 		}
// 	}
// 	if minwin == 1<<32 {
// 		return ""
// 	}
// 	return s[start:end]
// }

// type TreeNode struct {
// 	Val   int
// 	Left  *TreeNode
// 	Right *TreeNode
// }

// func generateTrees(n int) []*TreeNode {
// 	if n == 0 {
// 		return nil
// 	}
// 	return helper(1, n)
// }

// func fib(n int) int {
// 	if n <= 1 {
// 		return n
// 	}
// 	k := fib(n-1) + fib(n-2)
// 	return k
// }

// func helper(start, end int) []*TreeNode {
// 	if start > end {
// 		return []*TreeNode{nil}
// 	}
// 	allTrees := []*TreeNode{}
// 	for i := start; i <= end; i++ {
// 		leftTrees := helper(start, i-1)
// 		rightTrees := helper(i+1, end)

// 		for _, left := range leftTrees {
// 			for _, right := range rightTrees {
// 				currTree := &TreeNode{i, nil, nil}
// 				currTree.Left = left
// 				currTree.Right = right
// 				allTrees = append(allTrees, currTree)
// 				for _, v := range allTrees {
// fmt.Printf("%d", v.Val)
// 				}
// 			}
// 			fmt.Println()
// 		}

// 	}
// 	return allTrees
// }

// func generateTrees(n int) []*TreeNode {
// 	res := make([]*TreeNode)
// 	if n==0{
// 		return tree
// 	}
// 	nodes := make([]*TreeNode,n)
// 	for i:=0;i<n;i++{
// 		node := TreeNode{
// 			Val : i,
// 		}
// 		nodes[i] = node
// 	}
// 	for i:=0;i<n;i++{
// 		head := nodes[i]
// 		temp := nodes[:i]
// 		temp = append(temp,nodes[i+1:]...)
// 		for j:=0
// 	}

// }

// type ListNode struct {
// 	Val  int
// 	Next *ListNode
// }

// func swapPairs(head *ListNode) *ListNode {
// 	if head == nil || head.Next == nil {
// 		return head
// 	}
// 	temp := head.Next.Next
// 	k := head.Next
// 	k.Next = head
// 	head.Next = swapPairs(temp)
// 	return k

// }

// func swapPairs(head *ListNode) *ListNode {
// 	if head == nil || head.Next == nil {
// 		return head
// 	}

// 	dump := &ListNode{}
// 	dump.Next = head
// 	pre := dump

// 	for head != nil && head.Next != nil {
// 		las := head.Next
// 		temp := head.Next.Next
// 		las.Next = head
// 		head.Next = temp
// 		pre.Next = las
// 		pre = head
// 		head = temp
// 	}
// 	return dump.Next
// }

// func reverseString(s []byte) {
// 	res := make([]byte, 0)
// 	reverse(s, 0, &res)
// 	for i := 0; i < len(s); i++ {
// 		s[i] = res[i]
// 	}
// }

// func reverse(s []byte, i int, res *[]byte) {
// 	if i == len(s) {
// 		return
// 	}
// 	reverse(s, i+1, res)
// 	*res = append(*res, s[i])
// }

// func backPackII(m int, A []int, V []int) int {
// 	// write your code here
// 	if len(A) == 0 || len(V) == 0 {
// 		return 0
// 	}

// 	f := make([][]int, len(A)+1)
// 	for i := 0; i < len(A)+1; i++ {
// 		f[i] = make([]int, m+1)
// 	}
// 	for i := 0; i < len(A)+1; i++ {
// 		for j := 0; j < m+1; j++ {
// 			f[i][j] = -1
// 		}
// 	}
// 	f[0][0] = 0

// 	for i := 1; i < len(f); i++ {
// 		for j := 0; j < m+1; j++ {
// 			f[i][j] = f[i-1][j]
// 			if j-A[i-1] >= 0 && f[i-1][j-A[i-1]] != -1 {
// 				f[i][j] = max(f[i-1][j], V[i-1]+f[i-1][j-A[i-1]])
// 			}
// 		}
// 		//fmt.Println(f)
// 	}
// 	fmt.Println(f[len(A)])
// 	max := 0
// 	for i := m; i >= 0; i-- {
// 		if f[len(A)][i] > max {
// 			max = f[len(A)][i]
// 		}
// 	}
// 	return max
// }

// func backPack(m int, A []int) int {
// 	// write your code here
// 	f := make([][]bool, len(A)+1)

// 	for i := 0; i <= len(A); i++ {
// 		f[i] = make([]bool, m+1)
// 	}

// 	f[0][0] = true

// 	for i := 1; i < len(A)+1; i++ {
// 		for j := 0; j < m+1; j++ {
// 			f[i][j] = f[i-1][j]
// 			if j-A[i-1] >= 0 && f[i-1][j-A[i-1]] {
// 				f[i][j] = true
// 			}
// 		}
// 	}

// 	for i := m; i >= 0; i-- {
// 		if f[len(A)][i] == true {
// 			return i
// 		}
// 	}
// 	return 0
// }

// func backPack(m int, A []int) int {
// 	if len(A) == 0 {

// 		return 0
// 	}

// 	f := make([]int, m+1)
// 	for i := 1; i < len(f); i++ {
// 		f[i] = 0
// 	}
// 	f[0] = 0

// 	for i := 1; i < m+1; i++ {
// 		for j := 0; j < len(A); j++ {
// 			if i-A[j] >= 0 {
// 				f[i] = max(f[i], A[j]+f[i-2*A[j]])
// 			}
// 			fmt.Println(f)
// 		}
// 	}
// 	return f[m]
// }
// func backPack1(m int, A []int) int {
// 	if len(A) == 0 {

// 		return 0
// 	}

// 	f := make([]int, m+1)
// 	for i := 1; i < len(f); i++ {
// 		f[i] = 0
// 	}
// 	f[0] = 0

// 	for i := 1; i < m+1; i++ {
// 		temp := A

// 		for len(temp) != 0{

// 		}
// 	}
// 	return f[m]
// }
// func coinChange(coins []int, amount int) int {
// 	if len(coins) == 0 {
// 		return -1
// 	} else if len(coins) == 1 && amount%coins[0] != 0 {
// 		return -1
// 	}

// 	f := make([]int, amount+1)
// 	for i := 1; i < amount+1; i++ {
// 		f[i] = amount + 1
// 	}
// 	f[0] = 0
// 	for i := 1; i < amount+1; i++ {
// 		for j := 0; j < len(coins); j++ {
// 			if i-coins[j] >= 0 {
// 				f[i] = min(f[i], f[i-coins[j]]+1)
// 			}
// 		}
// 	}
// 	if f[amount] > amount {
// 		return -1
// 	} else {
// 		return f[amount]
// 	}
// }

// func coinChange(coins []int, amount int) int {
// 	if len(coins) == 0 {
// 		return -1
// 	} else if len(coins) == 1 && amount%coins[0] != 0 {
// 		return -1
// 	}

// 	f := make(map[int]int)
// 	f[0] = 0
// 	k := make([]int, len(coins))
// 	for i := 0; i < len(coins); i++ {
// 		f[coins[i]] = 1
// 		k[i] = coins[i]
// 	}
// 	//fmt.Println(f, k)
// 	for i := 1; i < amount+1; i++ {
// 		f[i] = (1 << 32)
// 		for j := 0; j < len(k); j++ {
// 			if i%k[j] == 0 {
// 				f[i] = i / k[j]
// 				break
// 			}
// 		}
// 		for j := 0; j < len(k); j++ {
// 			if i-k[j] >= 0 {
// 				f[i] = min(f[i], f[i-k[j]])
// 			}
// 		}
// 		f[i] += 1
// 		//fmt.Println(i, f)
// 	}
// 	return f[amount]
// }

// func minDistance(word1 string, word2 string) int {
// 	if len(word1) == 0 {
// 		return len(word2)
// 	} else if len(word2) == 0 {
// 		return len(word1)
// 	}

// 	f := make([][]int, len(word1)+1)
// 	for i := 0; i < len(f); i++ {
// 		f[i] = make([]int, len(word2)+1)
// 	}
// 	for i := 0; i < len(word2)+1; i++ {
// 		f[0][i] = i
// 	}
// 	for i := 0; i < len(word1)+1; i++ {
// 		f[i][0] = i
// 	}

// 	for i := 1; i < len(word1)+1; i++ {
// 		for j := 1; j < len(word2)+1; j++ {
// 			if word1[i] == word2[j] {
// 				f[i][j] = f[i-1][j-1]
// 			} else {
// 				f[i][j] = min(min(f[i-1][j-1], f[i-1][j]), f[i][j-1])
// 			}
// 		}
// 	}
// 	return f[len(word1)][len(word2)]
// }

// func longestCommonSubsequence(text1 string, text2 string) int {
// 	res := make([][]int, len(text1)+1)
// 	for i := 0; i < len(text1)+1; i++ {
// 		res[i] = make([]int, len(text2)+1)
// 	}

// 	for i := 1; i < len(text1)+1; i++ {
// 		for j := 1; j < len(text2)+1; j++ {
// 			if text1[i] == text2[j] {
// 				res[i][j] = res[i-1][j-1]
// 			} else {
// 				res[i][j] = max(res[i-1][j], res[i][j-1])
// 			}
// 		}
// 	}
// 	return res[len(text1)][len(text2)s]
// }

// func wordBreak(s string, wordDict []string) bool {
// 	wordmap := make(map[string]bool)
// 	for i := 0; i < len(wordDict); i++ {
// 		wordmap[wordDict[i]] = true
// 	}
// 	res := make([]bool, len(s))

// 	for i := 0; i < len(s); i++ {
// 		res[i] = false
// 		for j := 0; j < i; j++ {
// 			if _, ok := wordmap[s[j:i+1]]; (ok && j == 0) || (ok && res[j-1]) {
// 				res[i] = true
// 				break
// 			}
// 		}
// 	}
// 	return res[len(s)-1]
// }

// func lengthOfLIS(nums []int) int {
// 	if len(nums) == 0 || len(nums) == 1{
// 		return len(nums)
// 	}
// 	maxnum := 1
// 	res := make([]int, len(nums))
// 	res[0] = 1

// 	for i := 1; i < len(nums); i++ {
// 		res[i] = 1
// 		for j := 0; j < i; j++ {
// 			if nums[j] < nums[i] {
// 				res[i] = max(res[i], res[j]+1)
// 				if maxnum < res[i] {
// 					maxnum = res[i]
// 				}
// 			}
// 		}
// 	}
// 	return maxnum
// }

// func minCut(s string) int {
// 	if len(s) == 0 || len(s) == 1 {
// 		return 0
// 	}
// 	res := make([]int, len(s)+1)
// 	res[0] = -1
// 	res[1] = 0

// 	for i := 1; i < len(s); i++ {
//        res[i] = i
// 		for j := 0; j < i; j++ {
// 			if isReverse(s, i, j) {
// 				res[i] = min(res[i-1]+1, res[j]+1)
// 			}
// 		}
// 	}
// 	return res[len(s)-1]
// }

// func isReverse(s string, i, j int) bool {
// 	for j < i {
// 		if s[i] != s[j] {
// 			return false
// 		}
// 		i--
// 		j++
// 	}
// 	return true
// }

// func jump(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	steps := 0
// 	end := 0
// 	maxJump := 0

// 	for i := 0; i < len(nums)-1; i++ {
// 		if nums[i]+i > maxJump {
// 			maxJump = i
// 		}
// 		if end == i {
// 			end = maxJump
// 			steps++
// 		}
// 	}
// 	return steps
// }

// func jump(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}

// 	step := 0
// 	maxValue := 0
// 	end := 0

// 	for i := 0; i < len(nums)-1; i++ {
// 		maxValue = max(maxValue, i+nums[i])
// 		if i == end {
// 			end = maxValue
// 			step++
// 		}

// 	}
// 	return step
// }

// func jump(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}

// 	result := make([]int, len(nums))
// 	result[0] = 0

// 	for i := 1; i < len(nums); i++ {

// 		temp := 0
// 		for {
// 			if temp < i && nums[temp] < i-temp {
// 				temp++
// 				continue
// 			}
// 			break
// 		}

// 		result[i] = result[temp] + 1
// 		fmt.Println(result)
// 	}
// 	return result[len(nums)-1]
// }

// func jump(nums []int) int {
// 	if len(nums) == 0 {
// 		return 0
// 	}
// 	result := make([]int, len(nums))
// 	for i := 0; i < len(nums); i++ {
// 		result[i] = i
// 		for j := 0; j < i; j++ {
// 			if nums[j] >= i-j {
// 				result[i] = min(result[i], result[j]+1)
// 			}
// 		}
// 	}
// 	return result[len(nums)-1]
// }

// func canJump(nums []int) bool {
// 	if len(nums) == 0 {
// 		return false
// 	}
// 	num := len(nums) - 1
// 	for i := len(nums) - 2; i >= 0; i-- {
// 		if nums[i] >= num-i {
// 			num = i
// 		}
// 	}

// 	return num == 0
// }

// func climbStairs(n int) int {
// 	if n == 0 {
// 		return 0
// 	}
// 	f := make([]int, n+1)
// 	f[1] = 1
// 	f[2] = 2
// 	for i := 3; i <= n; i++ {
// 		f[i] = f[i-1] + f[i-2]
// 	}
// 	return f[n]
// }

// func uniquePathsWithObstacles(obstacleGrid [][]int) int {
// 	if len(obstacleGrid) == 0 || len(obstacleGrid[0]) == 0 {
// 		return 0
// 	}

// 	result := make([][]int, len(obstacleGrid))

// 	for i := 0; i < len(obstacleGrid); i++ {
// 		if result[i] == nil {
// 			result[i] = make([]int, len(obstacleGrid[i]))
// 		}
// 		for j := 0; j < len(obstacleGrid[i]); j++ {
// 			//fmt.Println(result)
// 			if obsta
// 			if i < 1 && j < 1 {
// 				result[i][j] = 1
// 			} else if i < 1 {
// 				if obstacleGrid[i][j-1] != 1 {
// 					result[i][j] += result[i][j-1]
// 				}

// 			} else if j < 1 {
// 				if obstacleGrid[i-1][j] != 1 {
// 					result[i][j] += result[i-1][j]
// 				}

// 			} else {
// 				if obstacleGrid[i][j-1] != 1 {
// 					result[i][j] += result[i][j-1]
// 				}
// 				if obstacleGrid[i-1][j] != 1 {
// 					result[i][j] += result[i-1][j]
// 				}
// 			}
// 		}
// 	}
// 	return result[len(obstacleGrid)-1][len(obstacleGrid[0])-1]
// }

// func uniquePaths(m int, n int) int {
// 	if m == 0 || n == 0 {
// 		return 0
// 	}
// 	result := make([][]int, m)
// 	for i := 0; i < m; i++ {
// 		if result[i] == nil {
// 			result[i] = make([]int, n)
// 		}
// 		for j := 0; j < n; j++ {
// 			if i < 1 && j < 1 {
// 				result[i][j] = 1
// 			} else if i < 1 {
// 				result[i][j] += result[i][j-1]
// 			} else if j < 1 {
// 				result[i][j] += result[i-1][j]
// 			} else {
// 				result[i][j] = result[i][j] + result[i-1][j] + result[i][j-1]
// 			}
// 		}
// 	}
// 	return result[m-1][n-1]
// }

//
// func minPathSum(grid [][]int) int {
// 	if len(grid) == 0 || len(grid[0]) == 0 {
// 		return 0
// 	}

// 	for i := 0; i < len(grid); i++ {
// 		for j := 0; j < len(grid[i]); j++ {
// 			if i < 1 && j < 1 {
// 				continue
// 			} else if i < 1 {
// 				grid[i][j] = grid[i][j] + grid[i][j-1]
// 			} else if j < 1 {
// 				grid[i][j] = grid[i][j] + grid[i-1][j]
// 			} else {
// 				grid[i][j] = grid[i][j] + min(grid[i-1][j], grid[i][j-1])
// 			}
// 		}
// 	}

// 	return grid[len(grid)-1][len(grid[0])-1]
// }

// func minimumTotal(triangle [][]int) int {
// 	result := make([][]int, len(triangle))
// 	if len(triangle) == 0 || len(triangle[0]) == 0 {
// 		return 0
// 	}
// 	for i := 0; i < len(triangle); i++ {
// 		for j := 0; j < len(triangle[i]); j++ {
// 			if result[i] == nil {
// 				result[i] = make([]int, len(triangle[i]))
// 			}
// 			result[i][j] = triangle[i][j]
// 		}
// 	}

// 	for i:=0;i<len(triangle)-1;i++{
// 		for j:=0;j<len(triangle[i]);j++{
// 				result[i+1][j] += result[i][j]
// 		}
// 	}

// }

// func minimumTotal(triangle [][]int) int {
// 	result := make([][]int, len(triangle))
// 	if len(triangle) == 0 || len(triangle[0]) == 0 {
// 		return 0
// 	}
// 	for i := 0; i < len(triangle); i++ {
// 		for j := 0; j < len(triangle[i]); j++ {
// 			if result[i] == nil {
// 				result[i] = make([]int, len(triangle[i]))
// 			}
// 			result[i][j] = triangle[i][j]
// 		}
// 	}

// 	for i := len(triangle) - 2; i >= 0; i++ {
// 		for j := 0; j < len(triangle[i]); j++ {
// 			result[i][j] = min(result[i+1][j], result[i+1][j+1]) + triangle[i][j]
// 		}
// 	}

// 	return result[0][0]
// }

//func min(x, y int) int {
// 	if x < y {
// 		return x
// 	}
// 	return y
// }

// func HeapSort(a []int) []int {
// 	for i := len(a)/2 - 1; i >= 0; i++ {
// 		sink(a, i, len(a))
// 	}

// 	for i := len(a) - 1; i >= 1; i-- {
// 		swap(a, 0, i)
// 		sink(a, 0, i)
// 	}
// 	return a
// }

// func sink(a []int, i int, length int) {
// 	for {
// 		l := 2*i + 1
// 		r := 2*i + 2
// 		idx := 1
// 		if l < length && a[l] > a[idx] {
// 			idx = l
// 		}
// 		if r < length && a[r] > a[idx] {
// 			idx = r
// 		}

// 		if idx == i {
// 			break
// 		}
// 		swap(a, i, idx)
// 		i = idx
// 	}
// }

// func QuickSort(nums []int) []int {
// 	quickSort(nums, 0, len(nums)-1)
// 	return nums
// }

// func MergeSort(nums []int) []int {
// 	return mergeSort(nums)
// }

// func mergeSort(nums []int) []int {
// 	if len(nums) <= 1 {
// 		return nums
// 	}

// 	left := mergeSort(nums[:(len(nums))/2])
// 	right := mergeSort(nums[(len(nums))/2:])
// 	result := merge(left, right)

// 	return result

// }

// func merge(left, right []int) []int {
// 	result := make([]int, 0)

// 	for len(left) != 0 && len(right) != 0 {
// 		l := left[0]
// 		r := right[0]
// 		if l < r {
// 			result = append(result, l)
// 			left = left[1:]
// 		} else {
// 			result = append(result, r)
// 			right = right[1:]
// 		}
// 	}

// 	result = append(result, right...)
// 	result = append(result, left...)
// 	return result
// }

// func quickSort(nums []int, start, end int) {
// 	if start < end {
// 		pivot := partition(nums, start, end)
// 		quickSort(nums, 0, pivot)
// 		quickSort(nums, pivot+1, end)

// 	}
// }

// func partition(nums []int, start, end int) int {
// 	p := nums[end]
// 	i := start

// 	for j := start; j < end; j++ {
// 		if nums[j] < p {
// 			swap(nums, i, j)
// 			i++
// 		}
// 	}
// 	swap(nums, i, end)
// 	return i
// }

// func swap(nums []int, i, j int) {
// 	nums[i], nums[j] = nums[j], nums[i]
// }

// func search(nums []int, target int) bool {
// 	if len(nums) == 0 {
// 		return false
// 	}

// 	start := 0
// 	end := len(nums) - 1

// 	for start+1 < end {

// 		for start < end {
// 			if nums[start] == nums[start+1] {
// 				start++
// 				continue
// 			}
// 			break
// 		}
// 		for start < end {
// 			if nums[end] == nums[end-1] {
// 				end--
// 				continue
// 			}
// 			break

// 		}
// 		mid := start + (end-start)/2
// 		if nums[mid] == target {
// 			return true
// 		}
// 		if nums[mid] > nums[end] {
// 			if nums[start] <= target && nums[mid] >= target {
// 				end = mid
// 			} else if nums[start] > target {
// 				start = mid
// 			}
// 		} else if nums[mid] < nums[end] {
// 			if nums[mid] <= target && nums[end] >= target {
// 				start = mid
// 			} else {
// 				end = mid
// 			}
// 		}
// 	}

// 	if nums[start] == target {
// 		return true
// 	}
// 	if nums[end] == target {
// 		return true
// 	}
// 	return false
// }

// func search(nums []int, target int) int {
// 	if len(nums) == 0 {
// 		return -1
// 	}
// 	start := 0
// 	end := len(nums) - 1

// 	for start+1 < end {
// 		mid := start + (end-start)/2
// 		if nums[mid] == target {
// 			return mid
// 		} else if nums[mid] > target && nums[start] <= target {
// 			end = mid
// 		} else if nums[mid] > target && nums[start] > target {
// 			start = mid
// 		} else if nums[mid] < target{
//             start = mid
//         }
// 	}

// 	if nums[start] == target {
// 		return start
// 	}
// 	if nums[end] == target {
// 		return end
// 	}
// 	return -1
// }

// func findMin(nums []int) int {
// 	if len(nums) == 0 {
// 		return -1
// 	}
// 	start := 0
// 	end := len(nums) - 1

// 	for start+1 < end {
// 		for start < end && nums[end] == nums[end-1] {
// 			end--
// 		}
// 		for start < end && nums[start] == nums[start+1] {
// 			start++
// 		}

// 		mid := start + (end-start)/2
// 		if nums[mid] <= nums[end] {
// 			end = mid
// 		} else {
// 			start = mid
// 		}
// 	}

// 	if nums[start] < nums[end] {
// 		return nums[start]
// 	} else {
// 		return nums[end]
// 	}

// }

// func firstBadVersion(n int) int {
// 	if n == 0 {
// 		return 0
// 	}
// 	start := 0
// 	end := n
// 	for start+1 < n {
// 		mid := start + (end-start)/2
// 		if isBadVersion(mid) == false {
// 			end = mid
// 		} else {
// 			start = mid
// 		}
// 	}
// 	if isBadVersion(start) == fasle {
// 		return start
// 	}
// 	if isBadVersion(end) == fasle {
// 		return end
// 	}
// 	return -1

// }
// func isBadVersion(version int) bool

// func searchMatrix(matrix [][]int, target int) bool {
// 	if len(matrix) == 0 {
// 		return false
// 	}

// 	row := len(matrix)
// 	col := len(matrix[0])

// 	start := 0
// 	end := row*col - 1

// 	for start+1 < end {
// 		mid := start + (end-start)/2
// 		if matrix[mid/col][mid%col] == target {
// 			return true

// 		} else if matrix[mid/col][mid%col] < target {
// 			start = mid
// 		} else if matrix[mid/col][mid%col] > target {
// 			end = mid
// 		}
// 	}
// 	if matrix[start/col][start%col] == target || matrix[end/col][end%col] {
// 		return true
// 	}
// 	return false
// }

// func searchMatrix(matrix [][]int, target int) bool {
// 	if len(matrix) == 0 {
// 		return false
// 	}

// 	for i := 0; i < len(matrix); i++ {
// 		res := twoSeek(matrix[i], target)
// 		if res == true {
// 			return true
// 		}
// 	}
// 	return false
// }

// func twoSeek(matrix []int, target int) bool {
// 	if len(matrix) == 0 {
// 		return false
// 	}
// 	start := 0
// 	end := len(matrix) - 1

// 	for start+1 < end {
// 		mid := start + (end-start)/2
// 		if matrix[mid] == target {
// 			return true
// 		} else if matrix[mid] > target {
// 			end = mid
// 		} else {
// 			start = mid
// 		}
// 	}
// 	if matrix[start] == target {
// 		return true
// 	}
// 	if matrix[end] == target {
// 		return true
// 	}
// 	return false
// }

// func searchInsert(nums []int, target int) int {
// 	if len(nums) == 0 {

// 		nums = append(nums, target)
// 		return 0
// 	}
// 	start := 0
// 	end := len(nums) - 1
// 	var mid int
// 	for start+1 < end {
// 		mid = start + (end-start)/2
// 		if nums[mid] == target {
// 			return mid
// 		} else if nums[mid] > target {
// 			end = mid
// 		} else if nums[mid] < target {
// 			start = mid
// 		}
// 	}

// 	if nums[start] == target {
// 		return start
// 	} else if nums[end] == target {
// 		return end
// 	}
// 	nums = append(append(nums[:mid+1], target), nums[mid+1:]...)
// 	return mid + 1
// }
//
//func searchRange(A []int, target int) []int {
//	if len(A) == 0 {
//		return []int{-1, -1}
//	}
//	result := make([]int, 2)
//	start := 0
//	end := len(A) - 1
//
//	for start+1 < end {
//		mid := start + (end-start)/2
//		if A[mid] > target {
//			end = mid
//		} else if A[mid] < target {
//			start = mid
//		} else {
//			end = mid
//		}
//	}
//	if A[start] == target {
//		result[0] = 0
//	} else if A[end] == target {
//		result[0] = end
//	} else {
//		result[0], result[1] = -1, -1
//		return result
//	}
//
//	end = len(A) - 1
//	for start+1 < end {
//		mid := start + (end-start)/2
//		if A[mid] > target {
//			end = mid
//		} else if A[mid] < target {
//			start = mid
//		} else {
//			start = mid
//		}
//	}
//	if A[end] == target {
//		result[1] = end
//	} else if A[start] == target {
//		result[0] = end
//	} else {
//		result[0], result[1] = -1, -1
//		return result
//	}
//	return result
//}

// func searchRange(A []int, target int) []int {
// 	start := 0
// 	end := len(A) - 1
// 	result := []int{-1, -1}
// 	if len(A) == 0 {
// 		return result
// 	} else if len(A) == 1 && A[0] == target {
// 		return []int{0, 0}
// 	}
// 	for start+1 < end {
// 		mid := start + (end-start)/2
// 		if A[mid] == target {
// 			num := mid
// 			result[1] = mid
// 			for num+1 <= end && A[num+1] == target {
// 				result[1] += 1
// 				num++
// 			}
// 			result[0] = mid
// 			num = mid
// 			for num-1 >= 0 && A[num-1] == target {
// 				result[0] -= 1
// 				num--
// 			}
// 			return result
// 		} else if A[mid] < target {
// 			start = mid
// 		} else if A[mid] > target {
// 			end = mid
// 		}
// 	}
// 	if A[start] == target && result[0] == -1 {
// 		return []int{0, 0}
// 	}
// 	if A[end] == target && result[0] == -1 {
// 		return []int{end.end}
// 	}
// 	return result
// }

// func rangeBitwiseAnd(left int, right int) int {
// 	sum := left
// 	for i := left; i <= right; i++ {
// 		sum &= i
// 	}
// 	return sum
// }
// func countBits(n int) []int {
// 	result := make([]int, 0)
// 	for i := 0; i <= n; i++ {
// 		result = append(result, hammingWeight(i))
// 	}
// 	return result
// }
// func hammingWeight(num int) int {

// 	sum := 0
// 	for i := 0; i < 64; i++ {
// 		if (num>>i)^1 == 1 {
// 			sum++
// 		}
// 	}
// 	return sum
// }

// func singleNumber(nums []int) []int {
// 	sum := 0
// 	for i := 0; i < len(nums); i++ {
// 		sum ^= nums[i]
// 	}
// 	temp := 0
// 	for i := 0; ; i++ {
// 		if (sum >> i & 1) == 1 {
// 			temp = i
// 			break
// 		}
// 	}
// 	res1 := 0
// 	for i := 0; i < len(nums); i++ {
// 		if (nums[i]>>temp)&1 == 1 {
// 			res1 ^= nums[i]
// 		}
// 	}
// 	res2 := sum ^ res1
// 	result := []int{res1, res2}
// 	return result
// }

// func singleNumber(nums []int) int {
// 	var result int
// 	sum := 0
// 	for i := 0; i < 64; i++ {
// 		for j := 0; j < len(nums); j++ {
// 			sum += (nums[j] >> i) & 1
// 		}
// 		result += (sum % 3 << i)
// 	}
// 	return result
// }

// func updateMatrix(mat [][]int) [][]int {
// 	if len(mat) == 0 {
// 		return mat
// 	}
// 	stack := make([][]int, 0)
// 	for i := 0; i < len(mat); i++ {
// 		for j := 0; j < len(mat[0]); j++ {
// 			if mat[i][j] == 0 {
// 				p := []int{i, j}
// 				stack = append(stack, p)
// 				continue
// 			}
// 			mat[i][j] = -1
// 		}
// 	}
// 	directions := [][]int{{0, 1}, {1, 0}, {-1, 0}, {0, -1}}
// 	for len(stack) != 0 {
// 		p := stack[0]
// 		stack = stack[1:]
// 		for _, v := range directions {
// 			x := p[0] + v[0]
// 			y := p[1] + v[1]
// 			if x >= 0 && x < len(mat) && y >= 0 && y < len(mat[0]) && mat[x][y] == -1 {
// 				mat[x][y] = mat[p[0]][p[1]] + 1
// 				s := []int{x, y}
// 				stack = append(stack, s)
// 			}
// 		}

// 	}
// 	return mat
// }

// type MyQueue struct {
// 	queue []int
// }

// /** Initialize your data structure here. */
// func Constructor() MyQueue {
// 	res := MyQueue{
// 		queue: make([]int, 0),
// 	}
// 	return res
// }

// /** Push element x to the back of queue. */
// func (this *MyQueue) Push(x int) {
// 	this.queue = append(this.queue, x)
// }

// /** Removes the element from in front of queue and returns that element. */
// func (this *MyQueue) Pop() int {
// 	res := this.queue[0]
// 	this.queue = this.queue[1:]
// 	return res
// }

// /** Get the front element. */
// func (this *MyQueue) Peek() int {
// 	return this.queue[0]
// }

// /** Returns whether the queue is empty. */
// func (this *MyQueue) Empty() bool {
// 	if len(this.queue) == 0 {
// 		return true
// 	}
// 	return false
// }

// func largestRectangleArea(heights []int) int {
// 	if len(heights) == 0 {
// 		return 0
// 	}
// 	var max int
// 	for i := 0; i < len(heights); i++ {
// 		num := i
// 		weight := 0
// 		height := heights[i]
// 		if i != 0 && heights[i] == heights[i-1]{
// 			break
// 		}
// 		for num >= 0 {
// 			if heights[num] >= height {
// 				weight++
// 				num -= 1
// 			} else {
// 				break
// 			}
// 		}
// 		num = i + 1
// 		for num <= len(heights)-1 {

// 			if heights[num] >= height {
// 				weight++
// 				num += 1
// 			} else {
// 				break
// 			}
// 		}
// 		//fmt.Println(weight * height)
// 		if weight*height > max {
// 			max = weight * height
// 		}
// 	}
// 	return max
// }

// func numIslands(grid [][]byte) int {
// 	if len(grid) == 0 {
// 		return 0
// 	}
// 	res := 0
// 	out := len(grid)
// 	ins := len(grid[0])
// 	for i := 0; i < out; i++ {
// 		for j := 0; j < ins; j++ {
// 			if grid[i][j] != '0' {
// 				DSPSeek(grid, i, j)
// 				//fmt.Println(res)
// 				res++
// 			}
// 		}
// 	}
// 	return res
// }

// func DSPSeek(grid [][]byte, i int, j int) {
// 	if grid[i][j] == '0' {
// 		return
// 	}
// 	if grid[i][j] == '1' {
// 		grid[i][j] = '0'
// 	}
// 	if i != 0 {
// 		DSPSeek(grid, i-1, j)
// 	}
// 	if j != 0 {
// 		DSPSeek(grid, i, j-1)
// 	}
// 	if i != len(grid)-1 {
// 		DSPSeek(grid, i+1, j)
// 	}
// 	if j != len(grid[0])-1 {
// 		DSPSeek(grid, i, j+1)
// 	}
// }

// type Node struct {
// 	Val       int
// 	Neighbors []*Node
// }

// func cloneGraph(node *Node) *Node {
// 	stack := make(map[*Node]*Node)
// 	res := ReverClone(node, stack)
// 	return res
// }

// func ReverClone(node *Node, stack map[*Node]*Node) *Node {
// 	if node == nil {
// 		return node
// 	}

// 	if v, ok := stack[node]; ok {

// 		return v
// 	}
// 	clonenode := &Node{
// 		Val:       node.Val,
// 		Neighbors: make([]*Node, len(node.Neighbors)),
// 	}

// 	stack[node] = clonenode
// 	for i := 0; i < len(node.Neighbors); i++ {
// 		clonenode.Neighbors = append(clonenode.Neighbors, ReverClone(node.Neighbors[i], stack))
// 	}
// 	return clonenode
// }

// func decodeString(s string) string {
// 	stack := make([]string, 0)
// 	var res string
// 	for len(s) != 0 {
// 		if s[0] == '[' {
// 			stack = append(stack, string(s[0]))
// 		} else if s[0] == ']' {
// 			var str string
// 			var num string
// 			for stack[len(stack)-1] != "[" {

// 				str = stack[len(stack)-1] + str
// 				stack = stack[:len(stack)-1]

// 			}
// 			stack = stack[:len(stack)-1]
// 			for len(stack) != 0 {
// 				_, r := strconv.Atoi(stack[len(stack)-1])
// 				if r != nil {
// 					break
// 				}
// 				num = stack[len(stack)-1] + num
// 				stack = stack[:len(stack)-1]
// 			}
// 			var result string
// 			intnum, _ := strconv.Atoi(num)
// 			for i := 0; i < intnum; i++ {
// 				result += s
// 			}

// 			if len(stack) == 0 {
// 				res += result
// 			} else {
// 				stack = append(stack, result)
// 			}

// 		} else {
// 			stack = append(stack, string(s[0]))
// 		}
// 		s = s[1:]
// 	}

// 	for len(stack) != 0 {
// 		res += stack[0]
// 		stack = stack[1:]
// 	}
// 	return res

// }

// func evalRPN(tokens []string) int {
// 	stack := make([]int, 0)

// 	for len(tokens) != 0 {
// 		if value, r := strconv.Atoi(tokens[0]); r == nil {
// 			stack = append(stack, value)
// 			//fmt.Println(value)

// 		} else if tokens[0] == "+" {
// 			res := stack[len(stack)-1] + stack[len(stack)-2]
// 			stack = stack[:len(stack)-2]
// 			stack = append(stack, res)

// 		} else if tokens[0] == "*" {
// 			res := stack[len(stack)-1] * stack[len(stack)-2]
// 			stack = stack[:len(stack)-2]
// 			stack = append(stack, res)

// 		} else if tokens[0] == "/" {
// 			res := stack[len(stack)-1] / stack[len(stack)-2]
// 			stack = stack[:len(stack)-2]
// 			stack = append(stack, res)

// 		} else if tokens[0] == "-" {
// 			res := stack[len(stack)-1] - stack[len(stack)-2]
// 			stack = stack[:len(stack)-2]
// 			stack = append(stack, res)

// 		} else {
// 			return -1
// 		}
// 		tokens = tokens[1:]

// 	}
// 	return stack[0]
// }

// type ListNode struct {
// 	Val  int
// 	Next *ListNode
// }

// // func deleteDuplicates(head *ListNode) *ListNode {
// // 	h := head
// // 	for h.Next != nil {
// // 		if h.Val == h.Next.Val {
// // 			h.Next = h.Next.Next
// // 			continue
// // 		}
// // 		h = h.Next
// // 	}
// // 	return head
// // }

// func deleteDuplicates(head *ListNode) *ListNode {
// 	dump := &ListNode{}
// 	dump.Next = head
// 	h := dump
// 	if head == nil {
// 		return nil
// 	}
// 	var k int
// 	for head.Next != nil {
// 		if head.Next.Val == head.Val {
// 			k = head.Val
// 			for head.Next != nil && head.Next.Val == k {
// 				head = head.Next
// 			}
// 			h.Next = head.Next
// 			head = head.Next
// 			if head == nil {
// 				break
// 			}
// 			continue
// 		}
// 		head = head.Next
// 		h = h.Next
// 	}
// 	return dump.Next
// }

// func reverseBetween(head *ListNode, left int, right int) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	bump := &ListNode{}
// 	bump.Next = head
// 	h := head

// 	for i := 0; i < left-1; i++ {
// 		head = head.Next
// 	}
// 	k := head
// 	var pre *ListNode
// 	for i := 0; i < right-left+1; i++ {
// 		temp := head.Next
// 		head.Next = pre
// 		pre = head
// 		head = temp

// 	}
// 	h.Next = pre
// 	k.Next = head

// 	return bump.Next

// }

// func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
// 	if l1 == nil {
// 		return l2
// 	} else if l2 == nil {
// 		return l1
// 	}
// 	head := &ListNode{}
// 	temp := head
// 	for l1 != nil && l2 != nil {
// 		if l1.Val > l2.Val {
// 			temp.Next = l2
// 			l2 = l2.Next
// 		} else {
// 			temp.Next = l1
// 			l1 = l1.Next
// 		}
// 		temp = temp.Next
// 	}

// 	if l1.Next != nil {
// 		temp.Next = l1
// 	}
// 	if l2.Next != nil {
// 		temp.Next = l2
// 	}
// 	return head.Next
// }

// func partition(head *ListNode, x int) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	dump := &ListNode{}
// 	h := dump
// 	dump.Next = head

// 	dumpmax := &ListNode{}
// 	k := dumpmax

// 	for head != nil {
// 		if head.Val >= x {
// 			k.Next = head
// 			k = k.Next
// 			h.Next = head.Next
// 			head = head.Next
// 			continue
// 		}
// 		h = h.Next
// 	}
// 	h.Next = dumpmax.Next
// 	return dump.Next
// }

// func sortList(head *ListNode) *ListNode {
// 	result := mergeSort(head)
// 	return result
// }

// func mergeSort(head *ListNode) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	middle := quickSlow(head)
// 	Last := middle.Next
// 	middle.Next = nil
// 	left := mergeSort(head)
// 	right := mergeSort(Last)
// 	res := mergeList(left, right)
// 	return res
// }

// func mergeList(l1 *ListNode, l2 *ListNode) *ListNode {
// 	if l1 == nil {
// 		return l2
// 	} else if l2 == nil {
// 		return l1
// 	}
// 	head := &ListNode{}
// 	temp := head
// 	for l1 != nil && l2 != nil {
// 		if l1.Val > l2.Val {
// 			temp.Next = l2
// 			l2 = l2.Next
// 		} else {
// 			temp.Next = l1
// 			l1 = l1.Next
// 		}
// 		temp = temp.Next
// 	}

// 	if l1.Next != nil {
// 		temp.Next = l1
// 	}
// 	if l2.Next != nil {
// 		temp.Next = l2
// 	}
// 	return head.Next
// }

// func reorderList(head *ListNode) {
// 	if head == nil || head.Next == nil {
// 		return
// 	}

// 	middle := quickSlow(head)
// 	tail := middle.Next
// 	middle.Next = nil
// 	dump := &ListNode{}
// 	pre := dump

// 	for tail != nil {
// 		temp := tail.Next
// 		tail.Next = pre
// 		pre = tail
// 		tail = temp
// 	}
// 	dump = dump.Next
// 	dump.Next = nil
// 	result := &ListNode{}
// 	k := result

// 	for head != nil && pre != nil {
// 		k.Next = head
// 		head = head.Next
// 		k = k.Next
// 		k.Next = pre
// 		pre = pre.Next
// 		k = k.Next
// 	}
// 	if head != nil {
// 		k.Next = head
// 	}
// 	if pre != nil {
// 		k.Next = pre
// 	}

// 	head = result.Next
// }

// func detectCycle(head *ListNode) *ListNode {
// 	if head == nil {
// 		return nil
// 	}

// 	slow := head
// 	fast := head.Next

// 	for fast != nil && fast.Next != nil {
// 		slow = slow.Next
// 		fast = fast.Next.Next
// 		if slow == fast {
// 			fast = fast.Next
// 			slow = head
// 			for slow != fast {
// 				slow = slow.Next
// 				fast = fast.Next
// 			}
// 			return slow
// 		}
// 	}

// 	return nil
// }

// func reverseList(head *ListNode) *ListNode {
// 	if head == nil {
// 		return nil
// 	}
// 	var pre *ListNode

// 	for head.Next != nil {
// 		temp := head.Next
// 		head.Next = pre
// 		pre = head
// 		head = temp
// 	}
// 	head.Next = pre
// 	return head
// }

// func quickSlow(head *ListNode) *ListNode {
// 	fast := head.Next
// 	slow := head

// 	for fast.Next != nil && fast.Next.Next != nil {
// 		fast = fast.Next.Next
// 		slow = slow.Next
// 	}

// 	return slow
// }

// func isPalindrome(head *ListNode) bool {
// 	if head == nil {
// 		return false
// 	}
// 	if head.Next == nil {
// 		return true
// 	}
// 	middle := quickSlow(head)
// 	tail := middle.Next
// 	middle.Next = nil

// 	newtail := reverseList(tail)

// 	for head != nil && newtail != nil {
// 		if head.Val != newtail.Val {
// 			return false
// 		}
// 	}
// 	return true

// }

// type Node struct {
// 	Val    int
// 	Next   *Node
// 	Random *Node
// }

// func copyRandomList(head *Node) *Node {
// 	if head == nil {
// 		return head
// 	}

// 	cur := head
// 	for cur != nil {
// 		temp := &Node{
// 			Val:  cur.Val,
// 			Next: cur.Next,
// 		}
// 		h := cur.Next
// 		cur.Next = temp
// 		cur = h
// 	}

// 	cur = head

// 	for cur != nil {
// 		if cur.Random != nil {
// 			cur.Next.Random = cur.Random.Next
// 		}
// 		cur = cur.Next.Next
// 	}

// 	cur = head
// 	cloneList := head.Next
// 	for cur != nil && cur.Next != nil {
// 		cur.Next = cur.Next.Next
// 		cur = cur.Next
// 	}
// 	return cloneList
// }

// type MinStack struct {
// 	min   []int
// 	stack []int
// }

// /** initialize your data structure here. */
// func Constructor() MinStack {
// 	stack := MinStack{}
// 	stack.min = make([]int, 0)
// 	stack.stack = make([]int, 0)
// 	return stack
// }

// func (this *MinStack) Push(val int) {
// 	if len(this.min) == 0 {
// 		this.stack = append(this.stack, val)
// 		this.min = append(this.min, this.min[len(this.min)-1])
// 	} else {
// 		if val < this.min[len(this.min)-1] {
// 			this.stack = append(this.stack, val)
// 			this.min = append(this.min, val)
// 		} else {
// 			this.stack = append(this.stack, val)
// 			this.min = append(this.min, this.min[len(this.min)-1])
// 		}
// 	}

// }

// func (this *MinStack) Pop() {
// 	this.stack = this.stack[:len(this.stack)-1]
// 	this.min = this.min[:len(this.min)-1]
// }

// func (this *MinStack) Top() int {
// 	return this.stack[len(this.stack)-1]
// }

// func (this *MinStack) GetMin() int {
// 	return this.min[len(this.min)-1]
// }
